<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
	<head>
		<title>Assertions</title>
<link href="../docs-assets/Breadcrumbs.css" rel="stylesheet" rev="stylesheet" type="text/css">
		<meta name="viewport" content="width=device-width initial-scale=1">
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
		<meta http-equiv="Content-Language" content="en-gb">

<link href="../docs-assets/Contents.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Progress.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Navigation.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Fonts.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Base.css" rel="stylesheet" rev="stylesheet" type="text/css">
<script>
function togglePopup(material_id) {
  var popup = document.getElementById(material_id);
  popup.classList.toggle("show");
}
</script>

<link href="../docs-assets/Popups.css" rel="stylesheet" rev="stylesheet" type="text/css">
<script>
MathJax = {
	tex: {
		inlineMath: '$', '$'], ['\\(', '\\)'
	},
	svg: {
		fontCache: 'global'
	}
};
</script>
<script type="text/javascript" id="MathJax-script" async
	src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-svg.js">
</script>

<link href="../docs-assets/Colours.css" rel="stylesheet" rev="stylesheet" type="text/css">
		
	</head>
	<body class="commentary-font">
		<nav role="navigation">
		<h1><a href="../index.html"><img src="../docs-assets/Inform.png" height=72> </a></h1>
<ul><li><a href="../index.html">home</a></li>
</ul><h2>Compiler</h2><ul>
<li><a href="../structure.html">structure</a></li>
<li><a href="../inbuildn.html">inbuild</a></li>
<li><a href="../inform7n.html">inform7</a></li>
<li><a href="../intern.html">inter</a></li>
<li><a href="../services.html">services</a></li>
<li><a href="../secrets.html">secrets</a></li>
</ul><h2>Other Tools</h2><ul>
<li><a href="../inblorbn.html">inblorb</a></li>
<li><a href="../inform6.html">inform6</a></li>
<li><a href="../inpolicyn.html">inpolicy</a></li>
</ul><h2>Resources</h2><ul>
<li><a href="../extensions.html">extensions</a></li>
<li><a href="../kits.html">kits</a></li>
</ul><h2>Repository</h2><ul>
<li><a href="https://github.com/ganelson/inform"><img src="../docs-assets/github.png" height=0> github</a></li>
</ul><h2>Related Projects</h2><ul>
<li><a href="https://github.com/ganelson/inweb"><img src="../docs-assets/github.png" height=0> inweb</a></li>
<li><a href="https://github.com/ganelson/intest"><img src="../docs-assets/github.png" height=0> intest</a></li>
</ul>
		</nav>
		<main role="main">
		<!-- Weave of 'Assertions' generated by inweb -->
<div class="breadcrumbs">
    <ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../inform7n.html">Inform7</a></li><li><a href="index.html">assertions</a></li><li><a href="index.html#4">Chapter 4: Assertions</a></li><li><b>Assertions</b></li></ul></div>
<p class="purpose">To infer facts about the model world, or take other action, based on sentences asserted as being true in the source text.</p>

<ul class="toc"><li><a href="4-ass.html#SP1">&#167;1. Existential assertions</a></li><li><a href="4-ass.html#SP2">&#167;2. Appearance assertions</a></li><li><a href="4-ass.html#SP3">&#167;3. Copula</a></li><li><a href="4-ass.html#SP4">&#167;4. The Matrix</a></li><li><a href="4-ass.html#SP6">&#167;6. Splitting into cases</a></li><li><a href="4-ass.html#SP6_3_1">&#167;6.3.1. Case 1. "A is B and C": process as "A is B" then "A is C"</a></li><li><a href="4-ass.html#SP6_3_2">&#167;6.3.2. Case 2</a></li><li><a href="4-ass.html#SP6_3_3">&#167;6.3.3. Case 3</a></li><li><a href="4-ass.html#SP6_3_4">&#167;6.3.4. Case 4. "A with B is C with D" must be incorrect</a></li><li><a href="4-ass.html#SP6_3_5">&#167;6.3.5. Case 5. "A and B are C": process as "A is C" then "B is C"</a></li><li><a href="4-ass.html#SP6_3_6">&#167;6.3.6. Case 6</a></li><li><a href="4-ass.html#SP6_3_7">&#167;6.3.7. Case 7</a></li><li><a href="4-ass.html#SP6_3_8">&#167;6.3.8. Case 8</a></li><li><a href="4-ass.html#SP6_3_9">&#167;6.3.9. Case 9</a></li><li><a href="4-ass.html#SP6_3_10">&#167;6.3.10. Case 10</a></li><li><a href="4-ass.html#SP6_3_11">&#167;6.3.11. Case 11</a></li><li><a href="4-ass.html#SP6_3_12">&#167;6.3.12. Case 12</a></li><li><a href="4-ass.html#SP6_3_13">&#167;6.3.13. Case 13</a></li><li><a href="4-ass.html#SP6_3_14">&#167;6.3.14. Case 14</a></li><li><a href="4-ass.html#SP6_3_15">&#167;6.3.15. Case 15. "An A with I is in B": the mirror image case</a></li><li><a href="4-ass.html#SP6_3_16">&#167;6.3.16. Case 16. "Every K is Y" and other oddities</a></li><li><a href="4-ass.html#SP6_3_17">&#167;6.3.17. Case 17</a></li><li><a href="4-ass.html#SP6_3_18">&#167;6.3.18. Case 18</a></li><li><a href="4-ass.html#SP6_3_19">&#167;6.3.19. Case 19</a></li><li><a href="4-ass.html#SP6_3_20">&#167;6.3.20. Case 20</a></li><li><a href="4-ass.html#SP6_3_21">&#167;6.3.21. Case 21</a></li><li><a href="4-ass.html#SP6_3_22">&#167;6.3.22. Case 22</a></li><li><a href="4-ass.html#SP6_3_23">&#167;6.3.23. Case 23. And so on</a></li><li><a href="4-ass.html#SP6_3_24">&#167;6.3.24. Case 24</a></li><li><a href="4-ass.html#SP6_3_25">&#167;6.3.25. Case 25</a></li><li><a href="4-ass.html#SP6_3_26">&#167;6.3.26. Case 26. At last, a correctly set property value</a></li><li><a href="4-ass.html#SP6_3_27">&#167;6.3.27. Case 27. Beginning some cases to do with actions..</a></li><li><a href="4-ass.html#SP6_3_28">&#167;6.3.28. Case 28</a></li><li><a href="4-ass.html#SP6_3_29">&#167;6.3.29. Case 29. Equating something to a single adjective</a></li><li><a href="4-ass.html#SP6_3_30">&#167;6.3.30. Case 30. I am in two minds about the next nit-picking error message</a></li><li><a href="4-ass.html#SP6_3_31">&#167;6.3.31. Case 31</a></li><li><a href="4-ass.html#SP6_3_32">&#167;6.3.32. Case 32. A problem message issued purely on stylistic grounds</a></li><li><a href="4-ass.html#SP6_3_33">&#167;6.3.33. Case 33</a></li><li><a href="4-ass.html#SP6_3_34">&#167;6.3.34. Case 34</a></li><li><a href="4-ass.html#SP6_3_35">&#167;6.3.35. Case 35</a></li><li><a href="4-ass.html#SP6_3_36">&#167;6.3.36. Case 36</a></li><li><a href="4-ass.html#SP6_3_37">&#167;6.3.37. Case 37. "On the table is a box." A mirror image, handling the inversion</a></li><li><a href="4-ass.html#SP6_3_38">&#167;6.3.38. Case 38</a></li><li><a href="4-ass.html#SP6_3_39">&#167;6.3.39. Case 39</a></li><li><a href="4-ass.html#SP6_3_40">&#167;6.3.40. Case 40. And so on, with one exemption</a></li><li><a href="4-ass.html#SP6_3_41">&#167;6.3.41. Case 41</a></li><li><a href="4-ass.html#SP6_3_42">&#167;6.3.42. Case 42</a></li><li><a href="4-ass.html#SP9">&#167;9. Instantiation of related kinds</a></li><li><a href="4-ass.html#SP10">&#167;10. Adjective list trees</a></li></ul><hr class="tocbar">

<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. Existential assertions.</b>These are very much simpler than coupling assertions, and the tree <span class="extract"><span class="extract-syntax">py</span></span>
can contain only a common noun together with requirements on it: for
example, the subtree for "an open door".
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::make_existential</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Assertions::make_existential</span></span>:<br/>Passes through Major Nodes - <a href="2-ptmn.html#SP3_1_2_2">&#167;3.1.2.2</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">py</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">WITH_NT:</span>
<span class="plain-syntax">                </span><a href="4-ass.html#SP1" class="function-link"><span class="function-syntax">Assertions::make_existential</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">AND_NT:</span>
<span class="plain-syntax">                </span><a href="4-ass.html#SP1" class="function-link"><span class="function-syntax">Assertions::make_existential</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><a href="4-ass.html#SP1" class="function-link"><span class="function-syntax">Assertions::make_existential</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">COMMON_NOUN_NT:</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">InferenceSubjects::is_a_kind_of_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))) ||</span>
<span class="plain-syntax">                    (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">K_object</span><span class="plain-syntax">, </span><span class="identifier-syntax">KindSubjects::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)))))</span>
<span class="plain-syntax">                    </span><a href="4-tc.html#SP8" class="function-link"><span class="function-syntax">Assertions::Creator::convert_instance_to_nounphrase</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ThereIsVague</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                        </span><span class="string-syntax">"'there is...' can only be used to create objects"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                        </span><span class="string-syntax">"and not instances of other kinds.'"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. Appearance assertions.</b>The "appearance" is not a property as such. When a quoted piece of text
is given as a whole sentence, it might be:
</p>

<ul class="items"><li>(a) the "description" of a room or thing;
</li><li>(b) the title of the whole work, if at the top of the main source; or
</li><li>(c) the rubric of the extension, or the additional credits for an extension,
if near the top of an extension file.
</li></ul>
<p class="commentary">The title of the work is handled elsewhere, so we worry only about (a) and (c).
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::make_appearance</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Assertions::make_appearance</span></span>:<br/>Passes through Major Nodes - <a href="2-ptmn.html#SP3_1_2">&#167;3.1.2</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">wn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">near_start_of_extension</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">1</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP2_1" class="named-paragraph-link"><span class="named-paragraph">This is rubric or credit text for an extension</span><span class="named-paragraph-number">2.1</span></a></span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">infs</span><span class="plain-syntax"> = </span><a href="2-ar.html#SP1" class="function-link"><span class="function-syntax">Anaphora::get_current_subject</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">infs</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP2_2" class="named-paragraph-link"><span class="named-paragraph">Issue a problem for appearance without object</span><span class="named-paragraph-number">2.2</span></a></span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">spec</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Rvalues::from_wording</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::one_word</span><span class="plain-syntax">(</span><span class="identifier-syntax">wn</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Properties::Appearance::infer</span><span class="plain-syntax">(</span><span class="identifier-syntax">infs</span><span class="plain-syntax">, </span><span class="identifier-syntax">spec</span><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP2_1" class="paragraph-anchor"></a><b>&#167;2.1. </b>The variable <span class="extract"><span class="extract-syntax">global_pass_state.near_start_of_extension</span></span> is always 0 except
at the start of an extension (immediately after the header line), when it is set
to 1. The following increments it to 2 to allow for up to two quoted lines; the
first is the rubric, the second the credit line.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is rubric or credit text for an extension</span><span class="named-paragraph-number">2.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">source_file</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pos</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Lexer::file_of_origin</span><span class="plain-syntax">(</span><span class="identifier-syntax">wn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">inform_extension</span><span class="plain-syntax"> *</span><span class="identifier-syntax">E</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Extensions::corresponding_to</span><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">E</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Word::dequote</span><span class="plain-syntax">(</span><span class="identifier-syntax">wn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">TEMPORARY_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">txt</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">txt</span><span class="plain-syntax">, </span><span class="string-syntax">"%W"</span><span class="plain-syntax">, </span><span class="identifier-syntax">Wordings::one_word</span><span class="plain-syntax">(</span><span class="identifier-syntax">wn</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">near_start_of_extension</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">1</span><span class="plain-syntax">: </span><span class="identifier-syntax">Extensions::set_rubric</span><span class="plain-syntax">(</span><span class="identifier-syntax">E</span><span class="plain-syntax">, </span><span class="identifier-syntax">txt</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">2</span><span class="plain-syntax">: </span><span class="identifier-syntax">Extensions::set_extra_credit</span><span class="plain-syntax">(</span><span class="identifier-syntax">E</span><span class="plain-syntax">, </span><span class="identifier-syntax">txt</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">near_start_of_extension</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">DISCARD_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">txt</span><span class="plain-syntax">)</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP2">&#167;2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP2_2" class="paragraph-anchor"></a><b>&#167;2.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue a problem for appearance without object</span><span class="named-paragraph-number">2.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_TextWithoutSubject</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"I'm not sure what you're referring to"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"that is, I can't decide to what room or thing you intend that text to belong. "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"Perhaps you could rephrase this more explicitly? ('The description of the Inner "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"Sanctum is...')"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP2">&#167;2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. Copula.</b>We now come to the main business, which is to act on "copula", that is,
couplings of two subtrees <span class="extract"><span class="extract-syntax">px</span></span> and <span class="extract"><span class="extract-syntax">py</span></span> representing things which are linked
by a copular verb. For example, in:
</p>

<blockquote>
    <p>The white marble is a thing.</p>
</blockquote>

<p class="commentary"><span class="extract"><span class="extract-syntax">px</span></span> would be the proper noun "white marble", <span class="extract"><span class="extract-syntax">py</span></span> the common noun "thing",
and the sentence is telling is what kind of value something has.
</p>

<p class="commentary">It is usually said that "to be" is the only copular verb in English, but it
got that way by blurring together several quite different meanings: consider
"I am 5", "I am happy" and "I am Chloe". (In French, for example, one would
say "I have five".) The definition of "to be" occupies 12 columns of the
Oxford English Dictionary; most computer programming languages implement only
<span class="extract"><span class="extract-syntax">=</span></span> and <span class="extract"><span class="extract-syntax">==</span></span>, which correspond to OED's meaning 10, "to exist as the thing
known by a certain name; to be identical with". But Inform implements a much
broader set of meanings. For example, its distinction between spatial and
property knowledge reflects the OED's distinction between meanings 5a ("to
have or occupy a place somewhere") and 9b ("to have a place among the things
distinguished by a specified quality") respectively.
</p>

<p class="commentary">Besides that, we expand the range of possible copula by considering sentences
like:
</p>

<blockquote>
    <p>The white marble is in the bamboo box.</p>
</blockquote>

<p class="commentary">as also being copula, but where <span class="extract"><span class="extract-syntax">py</span></span> is now a <span class="extract"><span class="extract-syntax">RELATIONSHIP_NT</span></span> subtree
expressing the sense of being inside the box.
</p>

<p class="commentary">So dealing with copula is not as simple as asserting that two things are
equal, and what we do falls into numerous cases.
</p>

<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. The Matrix.</b>What we do depends in the first instance on the node types of the head nodes of
the <span class="extract"><span class="extract-syntax">px</span></span> and <span class="extract"><span class="extract-syntax">py</span></span> subtrees. We want to be sure that we completely understand
this process and that no possibilities escape notice; we therefore use a matrix
of possible cases, as follows. <span class="extract"><span class="extract-syntax">py</span></span> specifies the row and <span class="extract"><span class="extract-syntax">px</span></span> the column.
</p>

<p class="commentary">The record size of this matrix in Inform's history is \(15\times 15\) with
58 numbered cases, but today there are "only" 42 cases in a \(12\times 12\)
grid. The cases are numbered upwards from 1, contiguously. There is no
significance to their ordering so far as the program's working is concerned;
but they are arranged in what seemed the best systematic way to group like
with like, by numbering from the top left to bottom right, and within each
cross-diagonal numbering from the centre outwards. The cases generally
increase in difficulty, with elementary syntax at the top left and quite
tricky semantics at the bottom right.
</p>

<pre class="definitions code-font"><span class="definition-keyword">define</span> <span class="constant-syntax">ASSERTION_MATRIX_DIM</span><span class="plain-syntax"> </span><span class="constant-syntax">12</span>
</pre>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">typedef</span><span class="plain-syntax"> </span><span class="reserved-syntax">struct</span><span class="plain-syntax"> </span><span class="reserved-syntax">matrix_entry</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">node_type_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">row_node_type</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">cases</span><span class="plain-syntax">[</span><span class="constant-syntax">ASSERTION_MATRIX_DIM</span><span class="plain-syntax">];</span>
<span class="plain-syntax">} </span><span class="reserved-syntax">matrix_entry</span><span class="plain-syntax">;</span>

<span class="reserved-syntax">matrix_entry</span><span class="plain-syntax"> </span><span class="identifier-syntax">assertion_matrix</span><span class="plain-syntax">[</span><span class="constant-syntax">ASSERTION_MATRIX_DIM</span><span class="plain-syntax">] = {</span>
<span class="plain-syntax">                   </span><span class="comment-syntax">  A,  W, XY,  K,  A, PL,  A,  A,  R,  E, CN, PN</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">AND_NT</span><span class="plain-syntax">,           {  </span><span class="constant-syntax">1</span><span class="plain-syntax">,  </span><span class="constant-syntax">2</span><span class="plain-syntax">,  </span><span class="constant-syntax">1</span><span class="plain-syntax">,  </span><span class="constant-syntax">1</span><span class="plain-syntax">,  </span><span class="constant-syntax">1</span><span class="plain-syntax">,  </span><span class="constant-syntax">1</span><span class="plain-syntax">,  </span><span class="constant-syntax">1</span><span class="plain-syntax">,  </span><span class="constant-syntax">1</span><span class="plain-syntax">,  </span><span class="constant-syntax">1</span><span class="plain-syntax">, </span><span class="constant-syntax">16</span><span class="plain-syntax">,  </span><span class="constant-syntax">1</span><span class="plain-syntax">,  </span><span class="constant-syntax">1</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">WITH_NT</span><span class="plain-syntax">,          {  </span><span class="constant-syntax">3</span><span class="plain-syntax">,  </span><span class="constant-syntax">4</span><span class="plain-syntax">,  </span><span class="constant-syntax">3</span><span class="plain-syntax">,  </span><span class="constant-syntax">3</span><span class="plain-syntax">,  </span><span class="constant-syntax">3</span><span class="plain-syntax">,  </span><span class="constant-syntax">3</span><span class="plain-syntax">,  </span><span class="constant-syntax">3</span><span class="plain-syntax">,  </span><span class="constant-syntax">3</span><span class="plain-syntax">, </span><span class="constant-syntax">14</span><span class="plain-syntax">, </span><span class="constant-syntax">16</span><span class="plain-syntax">,  </span><span class="constant-syntax">3</span><span class="plain-syntax">,  </span><span class="constant-syntax">3</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">X_OF_Y_NT</span><span class="plain-syntax">,        {  </span><span class="constant-syntax">5</span><span class="plain-syntax">,  </span><span class="constant-syntax">2</span><span class="plain-syntax">,  </span><span class="constant-syntax">6</span><span class="plain-syntax">,  </span><span class="constant-syntax">7</span><span class="plain-syntax">,  </span><span class="constant-syntax">9</span><span class="plain-syntax">,  </span><span class="constant-syntax">7</span><span class="plain-syntax">,  </span><span class="constant-syntax">7</span><span class="plain-syntax">,  </span><span class="constant-syntax">7</span><span class="plain-syntax">, </span><span class="constant-syntax">20</span><span class="plain-syntax">, </span><span class="constant-syntax">16</span><span class="plain-syntax">, </span><span class="constant-syntax">23</span><span class="plain-syntax">,  </span><span class="constant-syntax">7</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">KIND_NT</span><span class="plain-syntax">,          {  </span><span class="constant-syntax">5</span><span class="plain-syntax">,  </span><span class="constant-syntax">2</span><span class="plain-syntax">,  </span><span class="constant-syntax">8</span><span class="plain-syntax">,  </span><span class="constant-syntax">8</span><span class="plain-syntax">,  </span><span class="constant-syntax">9</span><span class="plain-syntax">,  </span><span class="constant-syntax">8</span><span class="plain-syntax">,  </span><span class="constant-syntax">8</span><span class="plain-syntax">,  </span><span class="constant-syntax">8</span><span class="plain-syntax">,  </span><span class="constant-syntax">8</span><span class="plain-syntax">, </span><span class="constant-syntax">16</span><span class="plain-syntax">,  </span><span class="constant-syntax">8</span><span class="plain-syntax">,  </span><span class="constant-syntax">8</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">ALLOWED_NT</span><span class="plain-syntax">,       {  </span><span class="constant-syntax">5</span><span class="plain-syntax">,  </span><span class="constant-syntax">2</span><span class="plain-syntax">, </span><span class="constant-syntax">10</span><span class="plain-syntax">, </span><span class="constant-syntax">10</span><span class="plain-syntax">,  </span><span class="constant-syntax">9</span><span class="plain-syntax">, </span><span class="constant-syntax">10</span><span class="plain-syntax">, </span><span class="constant-syntax">10</span><span class="plain-syntax">, </span><span class="constant-syntax">10</span><span class="plain-syntax">, </span><span class="constant-syntax">10</span><span class="plain-syntax">, </span><span class="constant-syntax">25</span><span class="plain-syntax">, </span><span class="constant-syntax">25</span><span class="plain-syntax">, </span><span class="constant-syntax">25</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">PROPERTY_LIST_NT</span><span class="plain-syntax">, {  </span><span class="constant-syntax">5</span><span class="plain-syntax">,  </span><span class="constant-syntax">2</span><span class="plain-syntax">, </span><span class="constant-syntax">11</span><span class="plain-syntax">, </span><span class="constant-syntax">12</span><span class="plain-syntax">,  </span><span class="constant-syntax">9</span><span class="plain-syntax">, </span><span class="constant-syntax">18</span><span class="plain-syntax">, </span><span class="constant-syntax">22</span><span class="plain-syntax">, </span><span class="constant-syntax">19</span><span class="plain-syntax">, </span><span class="constant-syntax">20</span><span class="plain-syntax">, </span><span class="constant-syntax">16</span><span class="plain-syntax">, </span><span class="constant-syntax">18</span><span class="plain-syntax">, </span><span class="constant-syntax">18</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">ADJECTIVE_NT</span><span class="plain-syntax">,     {  </span><span class="constant-syntax">5</span><span class="plain-syntax">,  </span><span class="constant-syntax">2</span><span class="plain-syntax">, </span><span class="constant-syntax">13</span><span class="plain-syntax">, </span><span class="constant-syntax">12</span><span class="plain-syntax">,  </span><span class="constant-syntax">9</span><span class="plain-syntax">, </span><span class="constant-syntax">22</span><span class="plain-syntax">, </span><span class="constant-syntax">22</span><span class="plain-syntax">, </span><span class="constant-syntax">24</span><span class="plain-syntax">, </span><span class="constant-syntax">20</span><span class="plain-syntax">, </span><span class="constant-syntax">16</span><span class="plain-syntax">, </span><span class="constant-syntax">29</span><span class="plain-syntax">, </span><span class="constant-syntax">29</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">ACTION_NT</span><span class="plain-syntax">,        {  </span><span class="constant-syntax">5</span><span class="plain-syntax">,  </span><span class="constant-syntax">2</span><span class="plain-syntax">, </span><span class="constant-syntax">11</span><span class="plain-syntax">, </span><span class="constant-syntax">19</span><span class="plain-syntax">,  </span><span class="constant-syntax">9</span><span class="plain-syntax">, </span><span class="constant-syntax">19</span><span class="plain-syntax">, </span><span class="constant-syntax">19</span><span class="plain-syntax">, </span><span class="constant-syntax">27</span><span class="plain-syntax">, </span><span class="constant-syntax">20</span><span class="plain-syntax">, </span><span class="constant-syntax">16</span><span class="plain-syntax">, </span><span class="constant-syntax">32</span><span class="plain-syntax">, </span><span class="constant-syntax">32</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">RELATIONSHIP_NT</span><span class="plain-syntax">,  {  </span><span class="constant-syntax">5</span><span class="plain-syntax">, </span><span class="constant-syntax">15</span><span class="plain-syntax">, </span><span class="constant-syntax">21</span><span class="plain-syntax">, </span><span class="constant-syntax">20</span><span class="plain-syntax">,  </span><span class="constant-syntax">9</span><span class="plain-syntax">, </span><span class="constant-syntax">20</span><span class="plain-syntax">, </span><span class="constant-syntax">42</span><span class="plain-syntax">, </span><span class="constant-syntax">20</span><span class="plain-syntax">, </span><span class="constant-syntax">28</span><span class="plain-syntax">, </span><span class="constant-syntax">31</span><span class="plain-syntax">, </span><span class="constant-syntax">34</span><span class="plain-syntax">, </span><span class="constant-syntax">36</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">EVERY_NT</span><span class="plain-syntax">,         { </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">33</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax">, </span><span class="constant-syntax">17</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">,   {  </span><span class="constant-syntax">5</span><span class="plain-syntax">,  </span><span class="constant-syntax">2</span><span class="plain-syntax">, </span><span class="constant-syntax">11</span><span class="plain-syntax">, </span><span class="constant-syntax">12</span><span class="plain-syntax">,  </span><span class="constant-syntax">9</span><span class="plain-syntax">, </span><span class="constant-syntax">18</span><span class="plain-syntax">, </span><span class="constant-syntax">30</span><span class="plain-syntax">, </span><span class="constant-syntax">19</span><span class="plain-syntax">, </span><span class="constant-syntax">35</span><span class="plain-syntax">, </span><span class="constant-syntax">16</span><span class="plain-syntax">, </span><span class="constant-syntax">38</span><span class="plain-syntax">, </span><span class="constant-syntax">39</span><span class="plain-syntax"> } },</span>
<span class="plain-syntax">{ </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">,   {  </span><span class="constant-syntax">5</span><span class="plain-syntax">,  </span><span class="constant-syntax">2</span><span class="plain-syntax">, </span><span class="constant-syntax">26</span><span class="plain-syntax">, </span><span class="constant-syntax">12</span><span class="plain-syntax">,  </span><span class="constant-syntax">9</span><span class="plain-syntax">, </span><span class="constant-syntax">18</span><span class="plain-syntax">, </span><span class="constant-syntax">30</span><span class="plain-syntax">, </span><span class="constant-syntax">19</span><span class="plain-syntax">, </span><span class="constant-syntax">37</span><span class="plain-syntax">, </span><span class="constant-syntax">16</span><span class="plain-syntax">, </span><span class="constant-syntax">40</span><span class="plain-syntax">, </span><span class="constant-syntax">41</span><span class="plain-syntax"> } } };</span>
</pre>
<ul class="endnotetexts"><li>The structure matrix_entry is private to this section.</li></ul>
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. </b>The following routine simply looks up which of the cases the current pair
of <span class="extract"><span class="extract-syntax">px</span></span> and <span class="extract"><span class="extract-syntax">py</span></span> falls into. Speed is not very important here.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::which_assertion_case</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">Assertions::which_assertion_case</span></span>:<br/><a href="4-ass.html#SP6">&#167;6</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">py</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">px</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"make assertion with px NULL"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">py</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"make assertion with py NULL"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><a href="4-ass.html#SP5" class="function-link"><span class="function-syntax">Assertions::allow_node_type</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">        (</span><a href="4-ass.html#SP5" class="function-link"><span class="function-syntax">Assertions::allow_node_type</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$T"</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$T"</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"make assertion with improper nodes"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">, </span><span class="identifier-syntax">x</span><span class="plain-syntax">=-1, </span><span class="identifier-syntax">y</span><span class="plain-syntax">=-1;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">node_type_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">wx</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">), </span><span class="identifier-syntax">wy</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">wx</span><span class="plain-syntax"> == </span><span class="identifier-syntax">PRONOUN_NT</span><span class="plain-syntax">) </span><span class="identifier-syntax">wx</span><span class="plain-syntax"> = </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">wy</span><span class="plain-syntax"> == </span><span class="identifier-syntax">PRONOUN_NT</span><span class="plain-syntax">) </span><span class="identifier-syntax">wy</span><span class="plain-syntax"> = </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;</span><span class="constant-syntax">ASSERTION_MATRIX_DIM</span><span class="plain-syntax">; </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">assertion_matrix</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">].</span><span class="element-syntax">row_node_type</span><span class="plain-syntax"> == </span><span class="identifier-syntax">wx</span><span class="plain-syntax">) </span><span class="identifier-syntax">x</span><span class="plain-syntax">=</span><span class="identifier-syntax">i</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">assertion_matrix</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">].</span><span class="element-syntax">row_node_type</span><span class="plain-syntax"> == </span><span class="identifier-syntax">wy</span><span class="plain-syntax">) </span><span class="identifier-syntax">y</span><span class="plain-syntax">=</span><span class="identifier-syntax">i</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">x</span><span class="plain-syntax">&lt;0) || (</span><span class="identifier-syntax">y</span><span class="plain-syntax">&lt;0)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$T"</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$T"</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"make assertion with node type not in matrix"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">assertion_matrix</span><span class="plain-syntax">[</span><span class="identifier-syntax">y</span><span class="plain-syntax">].</span><span class="element-syntax">cases</span><span class="plain-syntax">[</span><span class="identifier-syntax">x</span><span class="plain-syntax">];</span>
<span class="plain-syntax">}</span>

<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::allow_node_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">VerifyTree::verify_structure_from</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">NodeType::has_flag</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">), </span><span class="identifier-syntax">ASSERT_NFLAG</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. Splitting into cases.</b></p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::make_coupling</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">Assertions::make_coupling</span></span>:<br/><a href="4-ass.html#SP6_3_1">&#167;6.3.1</a>, <a href="4-ass.html#SP6_3_2">&#167;6.3.2</a>, <a href="4-ass.html#SP6_3_3">&#167;6.3.3</a>, <a href="4-ass.html#SP6_3_5">&#167;6.3.5</a>, <a href="4-ass.html#SP6_3_11">&#167;6.3.11</a>, <a href="4-ass.html#SP6_3_14">&#167;6.3.14</a>, <a href="4-ass.html#SP6_3_15">&#167;6.3.15</a>, <a href="4-ass.html#SP6_3_20">&#167;6.3.20</a>, <a href="4-ass.html#SP6_3_22">&#167;6.3.22</a>, <a href="4-ass.html#SP6_3_25">&#167;6.3.25</a>, <a href="4-ass.html#SP6_3_28">&#167;6.3.28</a>, <a href="4-ass.html#SP6_3_29">&#167;6.3.29</a>, <a href="4-ass.html#SP6_3_31">&#167;6.3.31</a>, <a href="4-ass.html#SP6_3_34">&#167;6.3.34</a>, <a href="4-ass.html#SP6_3_34_1">&#167;6.3.34.1</a>, <a href="4-ass.html#SP6_3_34_3">&#167;6.3.34.3</a>, <a href="4-ass.html#SP6_3_34_5">&#167;6.3.34.5</a>, <a href="4-ass.html#SP6_3_35">&#167;6.3.35</a>, <a href="4-ass.html#SP6_3_36">&#167;6.3.36</a>, <a href="4-ass.html#SP6_3_37">&#167;6.3.37</a>, <a href="4-ass.html#SP6_3_41_7">&#167;6.3.41.7</a>, <a href="4-ass.html#SP6_3_42">&#167;6.3.42</a><br/>Passes through Major Nodes - <a href="2-ptmn.html#SP3_1_2_2">&#167;3.1.2.2</a><br/>Define by Table Requests - <a href="3-dbtr.html#SP4_1_3">&#167;4.1.3</a><br/>The Creator - <a href="4-tc.html#SP8_4_1">&#167;8.4.1</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">py</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">LOG_INDENT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_assertion_recursive_inner</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">LOG_OUTDENT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>

<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::make_assertion_recursive_inner</span><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">py</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_1" class="named-paragraph-link"><span class="named-paragraph">See if any plugin wants to intervene in this assertion</span><span class="named-paragraph-number">6.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_2" class="named-paragraph-link"><span class="named-paragraph">Reject three forms of assertion</span><span class="named-paragraph-number">6.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax"> == </span><span class="identifier-syntax">INITIALLY_CE</span><span class="plain-syntax">) </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax"> = </span><span class="identifier-syntax">LIKELY_CE</span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">ma_case</span><span class="plain-syntax"> = </span><a href="4-ass.html#SP5" class="function-link"><span class="function-syntax">Assertions::which_assertion_case</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">LOGIF</span><span class="plain-syntax">(</span><span class="identifier-syntax">ASSERTIONS</span><span class="plain-syntax">, </span><span class="string-syntax">"[%W/$N] =%d [%W/$N]\n"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">), </span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">), </span><span class="identifier-syntax">ma_case</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">), </span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>

<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3" class="named-paragraph-link"><span class="named-paragraph">Split the assertion-handler into cases</span><span class="named-paragraph-number">6.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP6_1" class="paragraph-anchor"></a><b>&#167;6.1. </b>If a plugin sees fit to throw a problem message, we abandon the assertion.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">See if any plugin wants to intervene in this assertion</span><span class="named-paragraph-number">6.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">pc</span><span class="plain-syntax"> = </span><span class="identifier-syntax">problem_count</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">PluginCalls::intervene_in_assertion</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">problem_count</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">pc</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6">&#167;6</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_2" class="paragraph-anchor"></a><b>&#167;6.2. </b>These are better taken care of before we split up into cases.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Reject three forms of assertion</span><span class="named-paragraph-number">6.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax"> == </span><span class="identifier-syntax">INITIALLY_CE</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) != </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">) != </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_MisplacedInitially</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"you can only say 'initially' when creating variables using 'is'"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"so 'The squirrel population is initially 0' is fine, but not "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"'The acorn is initially carried by Mr Hedges.' - probably you "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"only need to remove the word 'initially'."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax"> != </span><span class="identifier-syntax">UNKNOWN_CE</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Rvalues::is_CONSTANT_construction</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">), </span><span class="identifier-syntax">CON_property</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Lvalues::is_actual_NONLOCAL_VARIABLE</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_VagueAboutSpecific</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"you can only equivocate with 'usually', 'rarely', "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"'always' and the like when talking about kinds of thing"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"because when a specific thing is involved you should say "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"definitely one way or another. 'A cave is usually dark' is "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"fine, but not 'the Mystic Wood is usually dark'."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        &amp;&amp; (</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) &amp;&amp; (</span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">multiplicity_ANNOT</span><span class="plain-syntax">) &gt; </span><span class="constant-syntax">1</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        &amp;&amp; (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">) != </span><span class="identifier-syntax">RELATIONSHIP_NT</span><span class="plain-syntax">)) ||</span>
<span class="plain-syntax">        ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">) == </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        &amp;&amp; (</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) &amp;&amp; (</span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">multiplicity_ANNOT</span><span class="plain-syntax">) &gt; </span><span class="constant-syntax">1</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        &amp;&amp; (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) != </span><span class="identifier-syntax">RELATIONSHIP_NT</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_implicit_in_creation_of</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">) == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"px = $T\npy=$T\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_MultiplyVague</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="string-syntax">"multiple objects can only be put into relationships"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"by saying something like 'In the Drawing Room are two women.', "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"and all other assertions with multiple objects are disallowed: "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"so 'Three doors are open.' is rejected - I can't tell which three."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6">&#167;6</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3" class="paragraph-anchor"></a><b>&#167;6.3. </b>The case names here are systematic and were constructed from the above
matrix by a Perl script, in an attempt to ensure their truthfulness; but they're
just labels, so should they be wrong the only consequence is that the code
in this section will be harder to understand.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Split the assertion-handler into cases</span><span class="named-paragraph-number">6.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">switch</span><span class="plain-syntax">(</span><span class="identifier-syntax">ma_case</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">1</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_1" class="named-paragraph-link"><span class="named-paragraph">Case 1 - Miscellaneous vs AND</span><span class="named-paragraph-number">6.3.1</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">2</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_2" class="named-paragraph-link"><span class="named-paragraph">Case 2 - WITH vs Miscellaneous</span><span class="named-paragraph-number">6.3.2</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">3</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_3" class="named-paragraph-link"><span class="named-paragraph">Case 3 - Miscellaneous vs WITH</span><span class="named-paragraph-number">6.3.3</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">4</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_4" class="named-paragraph-link"><span class="named-paragraph">Case 4 - WITH on both sides</span><span class="named-paragraph-number">6.3.4</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">5</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_5" class="named-paragraph-link"><span class="named-paragraph">Case 5 - AND vs Miscellaneous</span><span class="named-paragraph-number">6.3.5</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">6</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_6" class="named-paragraph-link"><span class="named-paragraph">Case 6 - X OF Y on both sides</span><span class="named-paragraph-number">6.3.6</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">7</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_7" class="named-paragraph-link"><span class="named-paragraph">Case 7 - Miscellaneous vs X OF Y</span><span class="named-paragraph-number">6.3.7</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">8</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_8" class="named-paragraph-link"><span class="named-paragraph">Case 8 - Miscellaneous vs KIND</span><span class="named-paragraph-number">6.3.8</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">9</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_9" class="named-paragraph-link"><span class="named-paragraph">Case 9 - ALLOWED vs Miscellaneous</span><span class="named-paragraph-number">6.3.9</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">10</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_10" class="named-paragraph-link"><span class="named-paragraph">Case 10 - Miscellaneous vs ALLOWED</span><span class="named-paragraph-number">6.3.10</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">11</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_11" class="named-paragraph-link"><span class="named-paragraph">Case 11 - X OF Y vs PROPERTY LIST, ACTION, COMMON NOUN</span><span class="named-paragraph-number">6.3.11</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">12</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_12" class="named-paragraph-link"><span class="named-paragraph">Case 12 - KIND vs PROPERTY LIST, ADJECTIVE, COMMON NOUN, PROPER NOUN</span><span class="named-paragraph-number">6.3.12</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">13</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_13" class="named-paragraph-link"><span class="named-paragraph">Case 13 - X OF Y vs ADJECTIVE</span><span class="named-paragraph-number">6.3.13</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">14</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_14" class="named-paragraph-link"><span class="named-paragraph">Case 14 - RELATIONSHIP vs WITH</span><span class="named-paragraph-number">6.3.14</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">15</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_15" class="named-paragraph-link"><span class="named-paragraph">Case 15 - WITH vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.15</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">16</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_16" class="named-paragraph-link"><span class="named-paragraph">Case 16 - EVERY vs Miscellaneous</span><span class="named-paragraph-number">6.3.16</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">17</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_17" class="named-paragraph-link"><span class="named-paragraph">Case 17 - Miscellaneous vs EVERY</span><span class="named-paragraph-number">6.3.17</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">18</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_18" class="named-paragraph-link"><span class="named-paragraph">Case 18 - PROPERTY LIST, COMMON NOUN, PROPER NOUN on both sides</span><span class="named-paragraph-number">6.3.18</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">19</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_19" class="named-paragraph-link"><span class="named-paragraph">Case 19 - ACTION, KIND, PROPERTY LIST, ADJECTIVE vs PROPERTY LIST, ACTION, COMMON NOUN, PROPER NOUN</span><span class="named-paragraph-number">6.3.19</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">20</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_20" class="named-paragraph-link"><span class="named-paragraph">Case 20 - Miscellaneous on both sides</span><span class="named-paragraph-number">6.3.20</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">21</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_21" class="named-paragraph-link"><span class="named-paragraph">Case 21 - X OF Y vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.21</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">22</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_22" class="named-paragraph-link"><span class="named-paragraph">Case 22 - ADJECTIVE, PROPERTY LIST vs PROPERTY LIST, ADJECTIVE</span><span class="named-paragraph-number">6.3.22</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">23</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_23" class="named-paragraph-link"><span class="named-paragraph">Case 23 - COMMON NOUN vs X OF Y</span><span class="named-paragraph-number">6.3.23</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">24</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_24" class="named-paragraph-link"><span class="named-paragraph">Case 24 - ACTION vs ADJECTIVE</span><span class="named-paragraph-number">6.3.24</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">25</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_25" class="named-paragraph-link"><span class="named-paragraph">Case 25 - EVERY, COMMON NOUN, PROPER NOUN vs ALLOWED</span><span class="named-paragraph-number">6.3.25</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">26</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_26" class="named-paragraph-link"><span class="named-paragraph">Case 26 - X OF Y vs PROPER NOUN</span><span class="named-paragraph-number">6.3.26</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">27</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_27" class="named-paragraph-link"><span class="named-paragraph">Case 27 - ACTION on both sides</span><span class="named-paragraph-number">6.3.27</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">28</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_28" class="named-paragraph-link"><span class="named-paragraph">Case 28 - RELATIONSHIP on both sides</span><span class="named-paragraph-number">6.3.28</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">29</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_29" class="named-paragraph-link"><span class="named-paragraph">Case 29 - COMMON NOUN, PROPER NOUN vs ADJECTIVE</span><span class="named-paragraph-number">6.3.29</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">30</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_30" class="named-paragraph-link"><span class="named-paragraph">Case 30 - ADJECTIVE vs COMMON NOUN, PROPER NOUN</span><span class="named-paragraph-number">6.3.30</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">31</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_31" class="named-paragraph-link"><span class="named-paragraph">Case 31 - EVERY vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.31</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">32</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_32" class="named-paragraph-link"><span class="named-paragraph">Case 32 - COMMON NOUN, PROPER NOUN vs ACTION</span><span class="named-paragraph-number">6.3.32</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">33</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_33" class="named-paragraph-link"><span class="named-paragraph">Case 33 - EVERY on both sides</span><span class="named-paragraph-number">6.3.33</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">34</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_34" class="named-paragraph-link"><span class="named-paragraph">Case 34 - COMMON NOUN vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.34</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">35</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_35" class="named-paragraph-link"><span class="named-paragraph">Case 35 - RELATIONSHIP vs COMMON NOUN</span><span class="named-paragraph-number">6.3.35</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">36</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_36" class="named-paragraph-link"><span class="named-paragraph">Case 36 - PROPER NOUN vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.36</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">37</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_37" class="named-paragraph-link"><span class="named-paragraph">Case 37 - RELATIONSHIP vs PROPER NOUN</span><span class="named-paragraph-number">6.3.37</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">38</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_38" class="named-paragraph-link"><span class="named-paragraph">Case 38 - COMMON NOUN on both sides</span><span class="named-paragraph-number">6.3.38</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">39</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_39" class="named-paragraph-link"><span class="named-paragraph">Case 39 - PROPER NOUN vs COMMON NOUN</span><span class="named-paragraph-number">6.3.39</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">40</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_40" class="named-paragraph-link"><span class="named-paragraph">Case 40 - COMMON NOUN vs PROPER NOUN</span><span class="named-paragraph-number">6.3.40</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">41</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41" class="named-paragraph-link"><span class="named-paragraph">Case 41 - PROPER NOUN on both sides</span><span class="named-paragraph-number">6.3.41</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">42</span><span class="plain-syntax">: </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_42" class="named-paragraph-link"><span class="named-paragraph">Case 42 - ADJECTIVE vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.42</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">default:</span><span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Unimplemented assertion case %d\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">ma_case</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"No implementation for make assertion case"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6">&#167;6</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_1" class="paragraph-anchor"></a><b>&#167;6.3.1. Case 1. "A is B and C": process as "A is B" then "A is C".</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 1 - Miscellaneous vs AND</span><span class="named-paragraph-number">6.3.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">across</span><span class="plain-syntax"> = </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">np</span><span class="plain-syntax"> = </span><span class="identifier-syntax">problem_count</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">across</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">np</span><span class="plain-syntax"> == </span><span class="identifier-syntax">problem_count</span><span class="plain-syntax">) </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">across</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">across</span><span class="plain-syntax"> = </span><span class="identifier-syntax">across</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_2" class="paragraph-anchor"></a><b>&#167;6.3.2. Case 2.</b>"An A with I is B" looks symmetrical with case 3, but is not. We might be
looking at an implication, for example:
</p>

<blockquote>
    <p>An open door is usually openable.</p>
</blockquote>

<p class="commentary">We allow this provided the properties I are all adjectival, and so is the
outcome B.
</p>

<p class="commentary">Otherwise we handle case 2 much like case 3, but more simply since the
result will normally be problem messages &mdash; not unreasonably given how
strange sentences like this are:
</p>

<blockquote>
    <p>A container with description "Solid." is the solid box.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 2 - WITH vs Miscellaneous</span><span class="named-paragraph-number">6.3.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><a href="4-ass.html#SP10" class="function-link"><span class="function-syntax">Assertions::is_adjlist</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)) &amp;&amp;</span>
<span class="plain-syntax">        (</span><a href="4-ass.html#SP10" class="function-link"><span class="function-syntax">Assertions::is_adjlist</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><a href="4-imp.html#SP3" class="function-link"><span class="function-syntax">Assertions::Implications::new</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) == </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">np</span><span class="plain-syntax"> = </span><span class="identifier-syntax">problem_count</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">); </span><span class="comment-syntax"> A is B</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">problem_count</span><span class="plain-syntax"> == </span><span class="identifier-syntax">np</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">); </span><span class="comment-syntax"> A is I</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">np</span><span class="plain-syntax"> = </span><span class="identifier-syntax">problem_count</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">); </span><span class="comment-syntax"> A is B</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">problem_count</span><span class="plain-syntax"> == </span><span class="identifier-syntax">np</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">); </span><span class="comment-syntax"> I is B</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_3" class="paragraph-anchor"></a><b>&#167;6.3.3. Case 3.</b>"A is a B with I": process as "A is a B" followed by "A is I", which
works nicely because we bend grammar to allow "is" in place of "has" when
it comes to lists of property values.
</p>

<blockquote>
    <p>The wickerwork box is a container with description "Pricy." The bat and ball are things with description "Cricket equipment." A trophy is a kind of container with score for finding 5.</p>
</blockquote>

<p class="commentary">An exception occurs with sentences like:
</p>

<blockquote>
    <p>South is a dead end with printed name "Collapsed Dead End".</p>
</blockquote>

<p class="commentary">Here <span class="extract"><span class="extract-syntax">px</span></span>, "south", refers not to the direction but to the room which lies
to the south of the location being talked about, which means that the printed
name must be given to the dead end, not to the direction "south". In this
case, on traverse 2 when properties are set, we process as "A is a B"
followed by "B is I". (On traverse 1, B is still an <span class="extract"><span class="extract-syntax">COMMON_NOUN_NT</span></span> node,
since it hasn't yet been instantiated into an actual but nameless room &mdash;
at which point it becomes a <span class="extract"><span class="extract-syntax">PROPER_NOUN_NT</span></span> node.)
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 3 - Miscellaneous vs WITH</span><span class="named-paragraph-number">6.3.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">IF_MODULE</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Map::subject_is_a_direction</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">))) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">np</span><span class="plain-syntax"> = </span><span class="identifier-syntax">problem_count</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">); </span><span class="comment-syntax"> A is a B</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">problem_count</span><span class="plain-syntax"> == </span><span class="identifier-syntax">np</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">); </span><span class="comment-syntax"> B is I</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">    #</span><span class="identifier-syntax">endif</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">np</span><span class="plain-syntax"> = </span><span class="identifier-syntax">problem_count</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">); </span><span class="comment-syntax"> A is a B</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">problem_count</span><span class="plain-syntax"> == </span><span class="identifier-syntax">np</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">); </span><span class="comment-syntax"> A is I</span>
<span class="plain-syntax">    #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">IF_MODULE</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    #</span><span class="identifier-syntax">endif</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_4" class="paragraph-anchor"></a><b>&#167;6.3.4. Case 4. "A with B is C with D" must be incorrect.</b></p>

<blockquote>
    <p>A container with description "White" is a container with description "Black".</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 4 - WITH on both sides</span><span class="named-paragraph-number">6.3.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_WithIsWith</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"you can't say that one general description is another "</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"for instance by writing 'A container with carrying capacity 10 is a "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"container with description \"Handy.\"'."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_5" class="paragraph-anchor"></a><b>&#167;6.3.5. Case 5. "A and B are C": process as "A is C" then "B is C".</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 5 - AND vs Miscellaneous</span><span class="named-paragraph-number">6.3.5</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">across</span><span class="plain-syntax"> = </span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">np</span><span class="plain-syntax"> = </span><span class="identifier-syntax">problem_count</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">across</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">np</span><span class="plain-syntax"> == </span><span class="identifier-syntax">problem_count</span><span class="plain-syntax">) </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">across</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">across</span><span class="plain-syntax"> = </span><span class="identifier-syntax">across</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_6" class="paragraph-anchor"></a><b>&#167;6.3.6. Case 6.</b>Now to begin on the <span class="extract"><span class="extract-syntax">XOFY_NT</span></span> cases, which look syntactically
like properties.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 6 - X OF Y on both sides</span><span class="named-paragraph-number">6.3.6</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_XofYisZofW</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this seems to say two different properties are not simply equal "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"but somehow the same thing"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"like saying that 'the printed name of the millpond is the "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"printed name of the village pond'. This puts me in a quandary: "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"which should be changed to match the other, and what if I am "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"unable to work out the value of either one?"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_7" class="paragraph-anchor"></a><b>&#167;6.3.7. Case 7.</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 7 - Miscellaneous vs X OF Y</span><span class="named-paragraph-number">6.3.7</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_BadXofY</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this is the wrong way around if you want to specify a property"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"like saying that '10 is the score of the platinum pyramid', "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"which is poor style. (Though sweet are the uses of adversity.)"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_8" class="paragraph-anchor"></a><b>&#167;6.3.8. Case 8.</b>"A is a kind of B". Much of the work has already been done at
refinement time. There are really four forms of this:
</p>

<ul class="items"><li>(a) "Length is a kind of value". Here <span class="extract"><span class="extract-syntax">px</span></span> doesn't refer to an instance.
</li><li>(b) "A figment is a kind". Here <span class="extract"><span class="extract-syntax">px</span></span> refers to a possibly new-made kind,
and <span class="extract"><span class="extract-syntax">py</span></span> refers to "kind".
</li><li>(c) "A cart is a kind of vehicle". Ditto, and <span class="extract"><span class="extract-syntax">py</span></span> refers to "vehicle".
</li><li>(d) "A food is a kind of thing which is edible". Ditto, except <span class="extract"><span class="extract-syntax">py</span></span> refers
of course to "thing", and also has a child node, containing a proposition
specifying its edibility.
</li></ul>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 8 - Miscellaneous vs KIND</span><span class="named-paragraph-number">6.3.8</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">KIND_NT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_8_4" class="named-paragraph-link"><span class="named-paragraph">Don't allow a kind of kind</span><span class="named-paragraph-number">6.3.8.4</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">EVERY_NT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_8_5" class="named-paragraph-link"><span class="named-paragraph">Don't allow a kind of everything</span><span class="named-paragraph-number">6.3.8.5</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax"> != </span><span class="identifier-syntax">UNKNOWN_CE</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_8_6" class="named-paragraph-link"><span class="named-paragraph">Don't allow a kind declaration to have uncertainty</span><span class="named-paragraph-number">6.3.8.6</span></a></span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">inst</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">kind_of_what</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">kind_of_what</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"KIND node without subject"</span><span class="plain-syntax">);</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">InferenceSubjects::is_an_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">inst</span><span class="plain-syntax">)) ||</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">InferenceSubjects::is_a_kind_of_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">inst</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">KindSubjects::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">inst</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">InferenceSubjects::where_created</span><span class="plain-syntax">(</span><span class="identifier-syntax">inst</span><span class="plain-syntax">) != </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">))</span>
<span class="plain-syntax">            </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_8_1" class="named-paragraph-link"><span class="named-paragraph">Don't allow an existing object to be declared as a kind over again</span><span class="named-paragraph-number">6.3.8.1</span></a></span><span class="plain-syntax">;</span>

<span class="plain-syntax">        </span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subject_to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">WITH_NT</span><span class="plain-syntax">)</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">subject_to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_creation_proposition</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">subject_to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_proposition</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        }</span>

<span class="plain-syntax">        </span><a href="8-cu.html#SP3" class="function-link"><span class="function-syntax">Propositions::Abstract::assert_kind_of_subject</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">inst</span><span class="plain-syntax">, </span><span class="identifier-syntax">kind_of_what</span><span class="plain-syntax">, </span><span class="identifier-syntax">subject_to</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_8_2" class="named-paragraph-link"><span class="named-paragraph">Don't allow an existing property name to be redeclared as a kind</span><span class="named-paragraph-number">6.3.8.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_8_3" class="named-paragraph-link"><span class="named-paragraph">Don't allow any existing actual value to be redeclared as a kind</span><span class="named-paragraph-number">6.3.8.3</span></a></span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_8_1" class="paragraph-anchor"></a><b>&#167;6.3.8.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Don't allow an existing object to be declared as a kind over again</span><span class="named-paragraph-number">6.3.8.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_subject</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">inst</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">InferenceSubjects::where_created</span><span class="plain-syntax">(</span><span class="identifier-syntax">inst</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_InstanceNowKind</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">        </span><span class="string-syntax">"You wrote '%2', but that seems to say that some "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"room or thing already created ('%1', created by '%3') is now to "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"become a kind. To prevent a variety of possible misunderstandings, "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this is not allowed: when a kind is created, the name given has "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"to be a name not so far used. (Sometimes this happens due to "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"confusion between names. For instance, if a room called 'Marble "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"archway' exists, then Inform reads 'An archway is a kind of thing', "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"Inform will read 'archway' as a reference to the existing room, "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"not as a new name. To solve this, put the sentences the other way "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"round.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_8">&#167;6.3.8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_8_2" class="paragraph-anchor"></a><b>&#167;6.3.8.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Don't allow an existing property name to be redeclared as a kind</span><span class="named-paragraph-number">6.3.8.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Rvalues::to_property</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_property</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">prn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_wording_as_source</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">prn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">name</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_KindAsProperty</span><span class="plain-syntax">));</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">                </span><span class="string-syntax">"You wrote '%1', but that seems to say that a property "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"(%3) has to be a kind as well. It is sometimes okay for a "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"property to have the same name as a kind, but only when that "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"kind is what it stores, and there shouldn't be a sentence "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"like this one to declare the kind - it will be made when the "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"property is made, and doesn't need to be made again."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_8">&#167;6.3.8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_8_3" class="paragraph-anchor"></a><b>&#167;6.3.8.3. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Don't allow any existing actual value to be redeclared as a kind</span><span class="named-paragraph-number">6.3.8.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::is</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</span><span class="plain-syntax">, </span><span class="identifier-syntax">CONSTANT_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_kind_of</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">val</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_wording_as_source</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_KindAsActualValue</span><span class="plain-syntax">));</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">                </span><span class="string-syntax">"You wrote '%1', but that seems to say that a value already "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"in existence (%3) has to be a kind as well. (It's %2.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_8">&#167;6.3.8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_8_4" class="paragraph-anchor"></a><b>&#167;6.3.8.4. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Don't allow a kind of kind</span><span class="named-paragraph-number">6.3.8.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_KindOfKindDisallowed</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"you aren't allowed to make new kinds of kinds"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"only kinds of things which already exist. So 'A fox is a kind of animal' "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"is fine, but 'A tricky kind is a kind of kind' isn't allowed."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_8">&#167;6.3.8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_8_5" class="paragraph-anchor"></a><b>&#167;6.3.8.5. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Don't allow a kind of everything</span><span class="named-paragraph-number">6.3.8.5</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_KindOfEveryDisallowed</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"you aren't allowed to make a kind of everything"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"or of everything matching a description. 'A badger is a kind of animal' "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"is fine, but 'A gene is a kind of every animal' isn't allowed. (Probably "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"you just need to get rid of the word 'every'.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_8">&#167;6.3.8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_8_6" class="paragraph-anchor"></a><b>&#167;6.3.8.6. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Don't allow a kind declaration to have uncertainty</span><span class="named-paragraph-number">6.3.8.6</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_KindUncertainDisallowed</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"you aren't allowed to make a kind in a way expressing certainty or doubt"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"so 'A badger is a kind of animal' is fine, but 'A fungus is usually a "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"kind of every animal' isn't allowed, and nor is 'A fern is never a kind "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"of animal'. When you tell me about kinds, you have to tell me certainly."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_8">&#167;6.3.8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_9" class="paragraph-anchor"></a><b>&#167;6.3.9. Case 9.</b>This can be proven never to happen, but just in case:
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 9 - ALLOWED vs Miscellaneous</span><span class="named-paragraph-number">6.3.9</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"Forbidden case 9 in make assertion has occurred."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_10" class="paragraph-anchor"></a><b>&#167;6.3.10. Case 10.</b>The syntax looks as if we are assigning a new property to something,
but it isn't a case where this would be legal. That doesn't mean it's hopeless:
this is where we assign variables to specific gadgets, which is in a way the
same thing.
</p>

<blockquote>
    <p>The before rulebook has a text called the standard demurral.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 10 - Miscellaneous vs ALLOWED</span><span class="named-paragraph-number">6.3.10</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">KIND_NT</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_10_1" class="named-paragraph-link"><span class="named-paragraph">Issue the too vague to have properties or variables problem message</span><span class="named-paragraph-number">6.3.10.1</span></a></span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_10_2" class="named-paragraph-link"><span class="named-paragraph">Issue the not allowed to have properties or variables problem message</span><span class="named-paragraph-number">6.3.10.2</span></a></span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_11" class="paragraph-anchor"></a><b>&#167;6.3.11. Case 11.</b>This is a catch-all sort of error. It might need narrowing into
further sub-cases later.
</p>

<blockquote>
    <p>The description of the Pitch is open.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 11 - X OF Y vs PROPERTY LIST, ACTION, COMMON NOUN</span><span class="named-paragraph-number">6.3.11</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">) == </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_kind_of</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_PropertyObj2</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"In %1 you give a value of a property as '%2', but it "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"seems to be a general description of a value (%3) rather than "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"nailing down exactly what the value should be."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">PluginCalls::unusual_property_value</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_PeculiarProperty</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"that is a very peculiar property value"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"and ought to be something more definite and explicit."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_12" class="paragraph-anchor"></a><b>&#167;6.3.12. Case 12.</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 12 - KIND vs PROPERTY LIST, ADJECTIVE, COMMON NOUN, PROPER NOUN</span><span class="named-paragraph-number">6.3.12</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_KindOfIs</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"that seems to say that a new kind is the same as something else"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"like saying 'A kind of container is a canister': which ought to be put the "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"other way round, 'A canister is a kind of container'."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_13" class="paragraph-anchor"></a><b>&#167;6.3.13. Case 13.</b>"The colour of the paint is white."
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 13 - X OF Y vs ADJECTIVE</span><span class="named-paragraph-number">6.3.13</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pred</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_predicate</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="8-aa.html#SP5" class="function-link"><span class="function-syntax">AdjectiveAmbiguity::has_enumerative_meaning</span></a><span class="plain-syntax">(</span><a href="8-tap.html#SP4" class="function-link"><span class="function-syntax">AdjectivalPredicates::to_adjective</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pred</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">ValueProperties::obtain</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">WITH_NT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_EOOwnerMutable</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="string-syntax">"either/or properties have to be given to clearly identifiable "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"owners"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"rather than to a collection of owners which might vary during "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"play. (It is possible to get around this using 'implications', "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"but it's better to avoid the need.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">            </span><a href="4-rpt.html#SP4" class="function-link"><span class="function-syntax">Refiner::turn_player_to_yourself</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><a href="4-pk.html#SP2" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::assert_property_value_from_property_subtree_infs</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">), </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_NonAdjectivalProperty</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"that property can't be used adjectivally as a value"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"since it is an adjective applying to a thing but is "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"not a name from a range of possibilities."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_14" class="paragraph-anchor"></a><b>&#167;6.3.14. Case 14.</b>"In A is a B with I": process as "In A is a B" followed by
"the newly created B is I".
</p>

<blockquote>
    <p>In the Pitch is a container with description "Made of wood."</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 14 - RELATIONSHIP vs WITH</span><span class="named-paragraph-number">6.3.14</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_15" class="paragraph-anchor"></a><b>&#167;6.3.15. Case 15. "An A with I is in B": the mirror image case.</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 15 - WITH vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.15</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_16" class="paragraph-anchor"></a><b>&#167;6.3.16. Case 16. "Every K is Y" and other oddities.</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 16 - EVERY vs Miscellaneous</span><span class="named-paragraph-number">6.3.16</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_BadEvery</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"'every' (or 'always') can't be used in that way"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"and should be reserved for sentences like 'A coin is in every room'."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_17" class="paragraph-anchor"></a><b>&#167;6.3.17. Case 17.</b>In fact one sentence like this can make sense &mdash; "The mist is
everywhere", or similar &mdash; but is handled by the spatial feature, if active.
Even then, of course, "everywhere" implicitly means "in every room",
not "every room".
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 17 - Miscellaneous vs EVERY</span><span class="named-paragraph-number">6.3.17</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_BadEvery2</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"'every' can't be used in that way"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"and should be reserved for sentences like 'A coin is in every room'."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_18" class="paragraph-anchor"></a><b>&#167;6.3.18. Case 18.</b>This are unlikely to be called as a top-level sentence with "is",
but will instead occur through recursion from <span class="extract"><span class="extract-syntax">WITH_NT</span></span> nodes, or as part of the
handling of "to have" rather than "to be".
</p>

<p class="commentary">Property lists may contain references to things not yet created, if we
assert them during pass 1: so we wait until pass 2.
</p>

<p class="commentary">The oddball exception for rulebooks is to add named outcomes:
</p>

<blockquote>
    <p>Reaching inside rules have outcomes allow access (success) and deny access (failure).</p>
</blockquote>

<p class="commentary">which syntactically resembles a property list, though in fact is not.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 18 - PROPERTY LIST, COMMON NOUN, PROPER NOUN on both sides</span><span class="named-paragraph-number">6.3.18</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Rvalues::is_CONSTANT_construction</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">), </span><span class="identifier-syntax">CON_rulebook</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><a href="6-fao.html#SP11" class="function-link"><span class="function-syntax">FocusAndOutcome::parse_properties</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">Rvalues::to_rulebook</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)),</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Wordings::new</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::left_edge_of</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">), </span><span class="identifier-syntax">Node::right_edge_of</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPERTY_LIST_NT</span><span class="plain-syntax">) </span><a href="4-pk.html#SP2" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::assert_property_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><a href="4-pk.html#SP2" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::assert_property_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_19" class="paragraph-anchor"></a><b>&#167;6.3.19. Case 19.</b>This usually occurs as a name-clash, since it's otherwise something
pretty improbable:
</p>

<blockquote>
    <p>Taking something is 100. The turn count is taking something.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 19 - ACTION, KIND, PROPERTY LIST, ADJECTIVE vs PROPERTY LIST, ACTION, COMMON NOUN, PROPER NOUN</span><span class="named-paragraph-number">6.3.19</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ActionEquated</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"an action can't be the same as a thing"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"so my guess is that this is an attempt to categorise an action which went "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"wrong because there was already something of that name in existence. For "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"instance, 'Taking something is theft' would fail if 'theft' was already a "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"value. (But it can also happen with a sentence which tries to set several "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"actions at once to a named kind of action, like 'Taking and dropping are "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"manipulation.' - only one can be named at a time.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ActionEquated2</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"that means something else already"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"so it will only confuse things if we use it for a kind of action."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_20" class="paragraph-anchor"></a><b>&#167;6.3.20. Case 20.</b>Hoovering up a variety of implausible things claimed to have
a spatial location.
</p>

<blockquote>
    <p>On the desk is 100. East of the Pitch is a rulebook.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 20 - Miscellaneous on both sides</span><span class="named-paragraph-number">6.3.20</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-rpt.html#SP4" class="function-link"><span class="function-syntax">Refiner::turn_player_to_yourself</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) { </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-rpt.html#SP4" class="function-link"><span class="function-syntax">Refiner::turn_player_to_yourself</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) { </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_IntangibleRelated</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this seems to give a worldly relationship to something intangible"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"like saying that 'in the box is a text'. Perhaps it came "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"to this because you gave something physical a name which was "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"accidentally something meaningful to me in another context? "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"If so, you may be able to get around it by rewording ('In the "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"box is a medieval text') or in extremis by using 'called' "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"('In the box is a thing called text')."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_21" class="paragraph-anchor"></a><b>&#167;6.3.21. Case 21.</b></p>

<blockquote>
    <p>The position of the weathervane is east of the church.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 21 - X OF Y vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.21</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_XofYRelated</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this seems to say that a property of something is not simply equal "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"to what happens at the moment to satisfy some relationship, but "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"conceptually the same as that relationship"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"like saying 'the position of the weathervane is east of the "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"church'. It would be fine to say 'the position of the weathervane "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"is east' or 'the position of the weathervane is the meadow', "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"because 'east' and 'meadow' are definite things."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_22" class="paragraph-anchor"></a><b>&#167;6.3.22. Case 22.</b>Most of the time, we're here because of an implicatory sentence like:
</p>

<blockquote>
    <p>Scenery is usually fixed in place.</p>
</blockquote>

<p class="commentary">But just maybe we have something like
</p>

<blockquote>
    <p>Guttering is inadequate.</p>
</blockquote>

<p class="commentary">where we are assigning a property ("inadequate") to a value ("guttering")
which can be used as an adjective, but isn't being so used here. So if it's
possible to coerce the left side to a noun, we will.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 22 - ADJECTIVE, PROPERTY LIST vs PROPERTY LIST, ADJECTIVE</span><span class="named-paragraph-number">6.3.22</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><a href="4-rpt.html#SP6" class="function-link"><span class="function-syntax">Refiner::nominalise_adjective</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><a href="4-imp.html#SP3" class="function-link"><span class="function-syntax">Assertions::Implications::new</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_23" class="paragraph-anchor"></a><b>&#167;6.3.23. Case 23. And so on.</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 23 - COMMON NOUN vs X OF Y</span><span class="named-paragraph-number">6.3.23</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_DescriptionIsOther</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this seems to say that a general description is something else"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"like saying that 'a door is 20'."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_24" class="paragraph-anchor"></a><b>&#167;6.3.24. Case 24.</b>Not as unlikely a mistake as it might seem:
</p>

<blockquote>
    <p>Taking something is open.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 24 - ACTION vs ADJECTIVE</span><span class="named-paragraph-number">6.3.24</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ActionAdjective</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"that is already the name of a property"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"so it will only confuse things if we use it for a kind of action."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_25" class="paragraph-anchor"></a><b>&#167;6.3.25. Case 25.</b>Here we are declaring a new property &mdash; either to an object, a kind
or a kind of value.
</p>

<blockquote>
    <p>A container has a number called security rating.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 25 - EVERY, COMMON NOUN, PROPER NOUN vs ALLOWED</span><span class="named-paragraph-number">6.3.25</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-rpt.html#SP4" class="function-link"><span class="function-syntax">Refiner::turn_player_to_yourself</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">spec</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Rvalues::is_CONSTANT_construction</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">, </span><span class="identifier-syntax">CON_property</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_constant_property</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prn</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">ValueProperties::coincides_with_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K</span><span class="plain-syntax"> = </span><span class="identifier-syntax">ValueProperties::kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_type_and_clear_annotations</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">KindSubjects::from_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">));</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">Specifications::from_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::is</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">, </span><span class="identifier-syntax">CONSTANT_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">PluginCalls::offered_property</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">, </span><span class="identifier-syntax">spec</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::get_construct</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">) == </span><span class="identifier-syntax">CON_activity</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_25_1" class="named-paragraph-link"><span class="named-paragraph">Assign a new activity variable</span><span class="named-paragraph-number">6.3.25.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::get_construct</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">) == </span><span class="identifier-syntax">CON_rulebook</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_25_2" class="named-paragraph-link"><span class="named-paragraph">Assign a new rulebook variable</span><span class="named-paragraph-number">6.3.25.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_10_2" class="named-paragraph-link"><span class="named-paragraph">Issue the not allowed to have properties or variables problem message</span><span class="named-paragraph-number">6.3.10.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><a href="4-npa.html#SP1" class="function-link"><span class="function-syntax">NewPropertyAssertions::recursively_declare</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_25_1" class="paragraph-anchor"></a><b>&#167;6.3.25.1. </b>Activities can optionally be referred to without the clarifier "activity",
but not in this context.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Assign a new activity variable</span><span class="named-paragraph-number">6.3.25.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">activity</span><span class="plain-syntax"> *</span><span class="identifier-syntax">av</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Rvalues::to_activity</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">av</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"failed to extract activity structure"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;activity-name-formal&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)))</span>
<span class="plain-syntax">            </span><a href="6-act.html#SP10" class="function-link"><span class="function-syntax">Activities::add_variable</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">av</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_BadActivityRef</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="string-syntax">"an activity has to be formally referred to in a way making clear that "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"it is indeed a rulebook when we give it named values"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"to reduce the risk of ambiguity. So 'The printing the banner text "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"activity has a number called the accumulated vanity' is fine, but "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"'Printing the banner text has a number called...' is not. (I'm "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"insisting on the presence of the word 'activity' because the "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"syntax is so close to that for giving properties to objects, and "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"it's important to avoid mistakes here.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_25">&#167;6.3.25</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_25_2" class="paragraph-anchor"></a><b>&#167;6.3.25.2. </b>And similarly for rulebooks.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Assign a new rulebook variable</span><span class="named-paragraph-number">6.3.25.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">rulebook</span><span class="plain-syntax"> *</span><span class="identifier-syntax">rb</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Rvalues::to_rulebook</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">rb</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"failed to extract rulebook structure"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;rulebook-name-formal&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)))</span>
<span class="plain-syntax">            </span><a href="6-rlb.html#SP15" class="function-link"><span class="function-syntax">Rulebooks::add_variable</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">rb</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_BadRulebookRef</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="string-syntax">"a rulebook has to be formally referred to in a way making clear that "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"it is indeed a rulebook when we give it named values"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"to reduce the risk of ambiguity. So 'The every turn rulebook has a "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"number called the accumulated bonus' is fine, but 'Every turn has a "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"number called...' is not. (I'm insisting on the presence of the word "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"'rulebook' because the syntax is so close to that for giving "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"properties to objects, and it's important to avoid mistakes here.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_25">&#167;6.3.25</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_10_1" class="paragraph-anchor"></a><b>&#167;6.3.10.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue the too vague to have properties or variables problem message</span><span class="named-paragraph-number">6.3.10.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_TooVagueForVariables</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this is too vague a description of the owner of the property"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"so that I don't know where to put this. Something like 'A person "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"has a number called age' is fine, but 'A kind has a number called "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"age' is not. Which kind?"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_10">&#167;6.3.10</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_10_2" class="paragraph-anchor"></a><b>&#167;6.3.10.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue the not allowed to have properties or variables problem message</span><span class="named-paragraph-number">6.3.10.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_HasNoVariables</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"only an object, kind, rulebook, action or activity can be allowed to have "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"properties or variables"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"so for instance 'A door has a colour' is fine but not 'A number has a length'."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_10">&#167;6.3.10</a> and <a href="4-ass.html#SP6_3_25">&#167;6.3.25</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_26" class="paragraph-anchor"></a><b>&#167;6.3.26. Case 26. At last, a correctly set property value.</b></p>

<blockquote>
    <p>The description of the Pitch is "Verdant." The desk is a container. The carrying capacity of the desk is 10.</p>
</blockquote>

<p class="commentary">Property assignments fall into three sorts, which we handle in this order:
</p>

<ul class="items"><li>(i) The specification pseudo-property, which looks syntactically like a property
but in fact isn't one;
</li><li>(ii) Properties of values and kinds of value;
</li><li>(iii) Properties of objects and kinds of object.
</li></ul>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 26 - X OF Y vs PROPER NOUN</span><span class="named-paragraph-number">6.3.26</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><a href="4-rpt.html#SP4" class="function-link"><span class="function-syntax">Refiner::turn_player_to_yourself</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;negated-clause&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::negative_sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_NonValue</span><span class="plain-syntax">)); </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">owner</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">ValueProperties::obtain</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prn</span><span class="plain-syntax"> == </span><span class="identifier-syntax">P_specification</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_26_1" class="named-paragraph-link"><span class="named-paragraph">We're setting the specification pseudo-property</span><span class="named-paragraph-number">6.3.26.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><a href="4-rpt.html#SP6" class="function-link"><span class="function-syntax">Refiner::nominalise_adjective</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">owner_infs</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">owner_infs</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;k-kind&gt;(Node::get_text(px-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">)))</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">owner_infs</span><span class="plain-syntax"> = </span><span class="identifier-syntax">KindSubjects::from_kind</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;&lt;rp&gt;&gt;</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Specifications::is_description</span><span class="plain-syntax">(</span><span class="identifier-syntax">owner</span><span class="plain-syntax">)) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">Specifications::is_kind_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">owner</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">))</span>
<span class="plain-syntax">            </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_26_2" class="named-paragraph-link"><span class="named-paragraph">Issue a problem message for setting a property of an overspecified object</span><span class="named-paragraph-number">6.3.26.2</span></a></span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">owner_infs</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><a href="4-pk.html#SP2" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::assert_property_value_from_property_subtree_infs</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner_infs</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_26_3" class="named-paragraph-link"><span class="named-paragraph">Issue a problem message for setting a property of something never having them</span><span class="named-paragraph-number">6.3.26.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_26_4" class="named-paragraph-link"><span class="named-paragraph">Issue a problem message for setting a property of something not owning one</span><span class="named-paragraph-number">6.3.26.4</span></a></span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_26_1" class="paragraph-anchor"></a><b>&#167;6.3.26.1. </b>This handles sentences like:
</p>

<blockquote>
    <p>The specification of vehicle is "A kind of thing able to move between rooms."</p>
</blockquote>

<p class="commentary">Specification is not a real property and has no existence at run-time; it's used
only to annotate the Index. For the most part it's set the way all other properties
are set, but exceptions are made for action names (which otherwise don't have
properties) and for kinds (which do, but differently).
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">We're setting the specification pseudo-property</span><span class="named-paragraph-number">6.3.26.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">W</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_26_1_1" class="named-paragraph-link"><span class="named-paragraph">Extract the raw text of a specification</span><span class="named-paragraph-number">6.3.26.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Specifications::is_kind_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">owner</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">owner</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::Behaviour::is_subkind_of_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">TEMPORARY_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">st</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">st</span><span class="plain-syntax">, </span><span class="string-syntax">"%+W"</span><span class="plain-syntax">, </span><span class="identifier-syntax">Wordings::one_word</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">)));</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Kinds::Behaviour::set_specification_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">, </span><span class="identifier-syntax">st</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">DISCARD_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">st</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">PluginCalls::offered_specification</span><span class="plain-syntax">(</span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">W</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) != </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$T\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_Unspecifiable</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"this tries to set specification text for a particular value"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"rather than a kind of value. 'Specification' is a special property used "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"only to annotate the Index, and it makes no sense to set this property for "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"anything other than a kind of value, a kind of object or an action."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_26">&#167;6.3.26</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_26_1_1" class="paragraph-anchor"></a><b>&#167;6.3.26.1.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Extract the raw text of a specification</span><span class="named-paragraph-number">6.3.26.1.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="function-syntax">&lt;s-literal&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">)) &amp;&amp; (</span><span class="identifier-syntax">Rvalues::is_CONSTANT_of_kind</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;&lt;rp&gt;&gt;</span><span class="plain-syntax">, </span><span class="identifier-syntax">K_text</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Word::dequote</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_SpecNotText</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"this tries to set a specification to something other than literal quoted text"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"which will not work. 'Specification' is a special property used only to "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"annotate the Index, and specifically the Kinds index, so it makes no sense to "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"set this property to anything other than text."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_26_1">&#167;6.3.26.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_26_2" class="paragraph-anchor"></a><b>&#167;6.3.26.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue a problem message for setting a property of an overspecified object</span><span class="named-paragraph-number">6.3.26.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_OverspecifiedSpec</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this tries to set a property for something more complicated than a single thing "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"named without qualifications"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"and that isn't allowed. For instance, 'The description of the Great Portal is "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"\"It's open.\"' is fine, but 'The description of the Great Portal in the Palace "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"is \"It's open.\"' is not allowed, because it tries to qualify 'Great Portal' "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"with the extra clause 'in the Palace'. (If you need to make a description which "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"changes based on where something is, or where it is seen from, try using text "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"substitutions.)"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_26">&#167;6.3.26</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_26_3" class="paragraph-anchor"></a><b>&#167;6.3.26.3. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue a problem message for setting a property of something never having them</span><span class="named-paragraph-number">6.3.26.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_BadInferenceSubject</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this tries to set a property for a value which can't have properties"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"and that isn't allowed. For instance, 'The description of the Great Portal is "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"\"It's open.\"' would be fine, if Great Portal were a room, but 'The description "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"of 6 is \"Sixish.\"' would not, because the number 6 isn't allowed to have "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"properties."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_26">&#167;6.3.26</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_26_4" class="paragraph-anchor"></a><b>&#167;6.3.26.4. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue a problem message for setting a property of something not owning one</span><span class="named-paragraph-number">6.3.26.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_GeneralitySpec</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this tries to set a property for a complicated generality of items all at once"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"which can lead to ambiguities. For instance, 'The description of an open door "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"is \"It's open.\"' is not allowed: if we followed Inform's normal conventions "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"strictly, that would be an instruction to create a new, nameless, open door and "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"give it the description. But this is very unlikely to be what the writer "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"intended, given the presence of the adjective to make it seem as if a particular "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"door is meant. So in fact we reject such sentences unless they refer only to a "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"kind, without adjectives: 'The description of a door is \"It's a door.\"' is "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"fine. (If the idea is actually to make the description change in play, we could "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"write a rule like 'Instead of examining an open door, say \"It's open.\"'; or "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"we could set the description of every door to \"[if open]It's open.[otherwise]It's "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"closed.\".)"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_26">&#167;6.3.26</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_27" class="paragraph-anchor"></a><b>&#167;6.3.27. Case 27. Beginning some cases to do with actions...</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 27 - ACTION on both sides</span><span class="named-paragraph-number">6.3.27</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">IF_MODULE</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">action_pattern</span><span class="plain-syntax"> *</span><span class="identifier-syntax">apx</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_action_meaning</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">action_pattern</span><span class="plain-syntax"> *</span><span class="identifier-syntax">apy</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_action_meaning</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">apy</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">ActionPatterns::is_named</span><span class="plain-syntax">(</span><span class="identifier-syntax">apy</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Actions: $A and $A\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">apx</span><span class="plain-syntax">, </span><span class="identifier-syntax">apy</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ActionsEquated</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"two actions are rather oddly equated here"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"which would only make sense if the second were a named pattern of actions "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"like (say) 'unseemly behaviour'."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">NamedActionPatterns::characterise</span><span class="plain-syntax">(</span><span class="identifier-syntax">apx</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    #</span><span class="identifier-syntax">endif</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_28" class="paragraph-anchor"></a><b>&#167;6.3.28. Case 28.</b>Sentence (1) below is deservedly rejected, but (2) makes a
non-reciprocal map connection: "D of the R is E of the S" is construed as
"D of the R is S" then "R is E of the S". We have to suppress Inform's
tendency to make tentative reciprocal map connections, because even though
they will only be listed as "likely", we know they are in fact impossible
in this case.
</p>

<blockquote>
    <p>(1) In the box is on the desk. (2) East of the Pitch is north of the Pavilion.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 28 - RELATIONSHIP on both sides</span><span class="named-paragraph-number">6.3.28</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">IF_MODULE</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">MapRelations::get_mapping_relationship</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">MapRelations::get_mapping_relationship</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Map::enter_one_way_mode</span><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Map::exit_one_way_mode</span><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    #</span><span class="identifier-syntax">endif</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_RelationsEquated</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this says that two different relations are the same"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"like saying that 'in the box is on the table'. (Sometimes this "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"happens if I misinterpret names of places like 'In Prison' or "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"'East of Fissure'.)"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_29" class="paragraph-anchor"></a><b>&#167;6.3.29. Case 29. Equating something to a single adjective.</b></p>

<blockquote>
    <p>The desk is fixed in place. A container is usually fixed in place.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 29 - COMMON NOUN, PROPER NOUN vs ADJECTIVE</span><span class="named-paragraph-number">6.3.29</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">sentence_is_existential_ANNOT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><a href="4-tc.html#SP8" class="function-link"><span class="function-syntax">Assertions::Creator::convert_instance_to_nounphrase</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Annotations::write_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">sentence_is_existential_ANNOT</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><a href="4-rpt.html#SP4" class="function-link"><span class="function-syntax">Refiner::turn_player_to_yourself</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Lvalues::get_nonlocal_variable_if_any</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)))) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-rpt.html#SP6" class="function-link"><span class="function-syntax">Refiner::nominalise_adjective</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><a href="4-pk.html#SP2" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::assert_property_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_30" class="paragraph-anchor"></a><b>&#167;6.3.30. Case 30. I am in two minds about the next nit-picking error message.</b>But really this is a device used in English only for declamatory purposes
or comedic intent. (As in Peter Schickele's spoof example of an 18th-century
opera about a dog, "Collared Is Bowser".)
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 30 - ADJECTIVE vs COMMON NOUN, PROPER NOUN</span><span class="named-paragraph-number">6.3.30</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_AdjectiveIsObject</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"that seems to say that an adjective is a noun"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"like saying 'Open are the doubled doors': which I'm picky about, preferring "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"it written the other way about ('The doubled doors are open'). Less poetic, "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"but clearer style."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_AdjectiveIsValue</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"that suggests that an adjective has some sort of value"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"like saying 'Open is a number' or 'Scenery is 5': but of course an adjective "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"represents something which is either true or false."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_31" class="paragraph-anchor"></a><b>&#167;6.3.31. Case 31.</b>"Every K is in L."
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 31 - EVERY vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.31</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Diagrams::is_possessive_RELATIONSHIP</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;k-kind&gt;(Node::get_text(py-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">ALLOWED_NT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">UNPARSED_NOUN_NT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><a href="4-ass2.html#SP8" class="function-link"><span class="function-syntax">Assertions::Assemblies::make_generalisation</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_32" class="paragraph-anchor"></a><b>&#167;6.3.32. Case 32. A problem message issued purely on stylistic grounds.</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 32 - COMMON NOUN, PROPER NOUN vs ACTION</span><span class="named-paragraph-number">6.3.32</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) &amp;&amp; (</span><span class="identifier-syntax">KindSubjects::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_KindIsAction</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"You wrote %1: unfortunately %2 is already the name of an action, "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"and it would only confuse things if we used it for a value as well."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">v</span><span class="plain-syntax"> = </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::is</span><span class="plain-syntax">(</span><span class="identifier-syntax">v</span><span class="plain-syntax">, </span><span class="identifier-syntax">VERB_NT</span><span class="plain-syntax">)) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">v</span><span class="plain-syntax">, </span><span class="identifier-syntax">verbal_certainty_ANNOT</span><span class="plain-syntax">) == </span><span class="identifier-syntax">INITIALLY_CE</span><span class="plain-syntax">))</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ObjectIsAction2</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="string-syntax">"you need to add 'the action of' after 'initially'"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"in order to clarify that you mean this sentence to set a variable "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"to an action (if in fact that's what you mean to do!)."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ObjectIsAction</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="string-syntax">"that is putting the definition back to front"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"since I need these categorisations of actions to take the form 'Kissing a "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"woman is love', not 'Love is kissing a woman'. (This is really because it "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"is better style: love might be many other things too, and we don't want to "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"imply that the present definition is all-inclusive.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_33" class="paragraph-anchor"></a><b>&#167;6.3.33. Case 33.</b>"Every K is every L."
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 33 - EVERY on both sides</span><span class="named-paragraph-number">6.3.33</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_EveryEquated</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"I can't do that"</span><span class="plain-syntax">, </span><span class="string-syntax">"Dave."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_34" class="paragraph-anchor"></a><b>&#167;6.3.34. Case 34.</b>The "Genevieve" problem message is a finicky stylistic one, and
it I suspect it may be disliked. I've always been in two minds about whether
this ought to be allowed...
</p>

<blockquote>
    <p>An animal is in the desk.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 34 - COMMON NOUN vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.34</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_34_1" class="named-paragraph-link"><span class="named-paragraph">Possession of something is allowed</span><span class="named-paragraph-number">6.3.34.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_34_2" class="named-paragraph-link"><span class="named-paragraph">Generalised relationships are allowed</span><span class="named-paragraph-number">6.3.34.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_34_3" class="named-paragraph-link"><span class="named-paragraph">Multiple objects in a relationship are allowed</span><span class="named-paragraph-number">6.3.34.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_34_4" class="named-paragraph-link"><span class="named-paragraph">Certain non-spatial relationships are allowed too</span><span class="named-paragraph-number">6.3.34.4</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_34_5" class="named-paragraph-link"><span class="named-paragraph">There is... relationships are allowed too</span><span class="named-paragraph-number">6.3.34.5</span></a></span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax"> == </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Node::set_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">KindSubjects::from_kind</span><span class="plain-syntax">(</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">))));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Node::set_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">EVERY_NT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::Behaviour::is_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">))))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_KindRelated</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"something described only by its kind should not be given a "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"specific place or role in the world"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"to avoid ambiguity. For instance, suppose 'car' is a kind. Then "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"we are not allowed to say 'a car is in the garage': there's too "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"much risk of confusion between whether an individual (but "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"nameless) car is referred to, or whether cars are generically to "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"be found there. Sentences of this form are therefore prohibited, "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"though more specific ones like 'a car called Genevieve is in the "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"garage' are fine, as is the reverse, 'In the garage is a car.'"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_KOVRelated</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"this seems to give a worldly relationship to something intangible"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"possibly due to an accidental clash of names between a kind of "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"value and something in the real world. "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"I sometimes read sentences like 'There is a number on the "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"door' or 'A text is in the prayer-box' literally - thinking "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"you mean a whole number or a piece of double-quoted text, and "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"not realising you intended to make a brass number-plate or "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"an old book. If that's the trouble, you can use 'called': "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"for instance, 'In the prayer-box is a thing called the text.'"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_34_1" class="paragraph-anchor"></a><b>&#167;6.3.34.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Possession of something is allowed</span><span class="named-paragraph-number">6.3.34.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Diagrams::is_possessive_RELATIONSHIP</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;k-kind&gt;(Node::get_text(py-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">ALLOWED_NT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">UNPARSED_NOUN_NT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_34">&#167;6.3.34</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_34_2" class="paragraph-anchor"></a><b>&#167;6.3.34.2. </b>For example,
</p>

<blockquote>
    <p>An animal is in every desk.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Generalised relationships are allowed</span><span class="named-paragraph-number">6.3.34.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">EVERY_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><a href="4-ass2.html#SP8" class="function-link"><span class="function-syntax">Assertions::Assemblies::make_generalisation</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_34">&#167;6.3.34</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_34_3" class="paragraph-anchor"></a><b>&#167;6.3.34.3. </b>For example,
</p>

<blockquote>
    <p>Six animals are in the desk.</p>
</blockquote>

<p class="commentary">Note that the default multiplicity is 0, not 1; saying "one door" has a
slightly different meaning from simply saying "a door", since it clarifies
that we're discussing a number of actual objects, not the category of doors
in general.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Multiple objects in a relationship are allowed</span><span class="named-paragraph-number">6.3.34.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">multiplicity_ANNOT</span><span class="plain-syntax">) &gt;= </span><span class="constant-syntax">1</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><a href="4-tc.html#SP8" class="function-link"><span class="function-syntax">Assertions::Creator::convert_instance_to_nounphrase</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_34">&#167;6.3.34</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_34_4" class="paragraph-anchor"></a><b>&#167;6.3.34.4. </b>Further exceptions are made for sentences like:
</p>

<blockquote>
    <p>A chair usually allows sitting. A thing usually weighs 1kg.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Certain non-spatial relationships are allowed too</span><span class="named-paragraph-number">6.3.34.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_relationship</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">bp</span><span class="plain-syntax">) &amp;&amp; ((</span><span class="identifier-syntax">SettingPropertyRelations::bp_sets_a_property</span><span class="plain-syntax">(</span><span class="identifier-syntax">bp</span><span class="plain-syntax">)) ||</span>
<span class="plain-syntax">        (</span><a href="8-er.html#SP4" class="function-link"><span class="function-syntax">ExplicitRelations::relates_values_not_objects</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">bp</span><span class="plain-syntax">)))) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><a href="4-rk.html#SP1" class="function-link"><span class="function-syntax">Assertions::Relational::assert_subtree_in_relationship</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_34">&#167;6.3.34</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_34_5" class="paragraph-anchor"></a><b>&#167;6.3.34.5. </b>And also for "There is..." sentences:
</p>

<blockquote>
    <p>There is a coin in the strongbox.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">There is... relationships are allowed too</span><span class="named-paragraph-number">6.3.34.5</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">sentence_is_existential_ANNOT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><a href="4-tc.html#SP8" class="function-link"><span class="function-syntax">Assertions::Creator::convert_instance_to_nounphrase</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_34">&#167;6.3.34</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_35" class="paragraph-anchor"></a><b>&#167;6.3.35. Case 35.</b></p>

<blockquote>
    <p>In the desk is a copy of Wisden. On the table is a container.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 35 - RELATIONSHIP vs COMMON NOUN</span><span class="named-paragraph-number">6.3.35</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">) == </span><span class="identifier-syntax">EVERY_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><a href="4-ass2.html#SP8" class="function-link"><span class="function-syntax">Assertions::Assemblies::make_generalisation</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><a href="4-tc.html#SP8" class="function-link"><span class="function-syntax">Assertions::Creator::convert_instance_to_nounphrase</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_relationship</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_36" class="paragraph-anchor"></a><b>&#167;6.3.36. Case 36.</b>"A box is on the table." This makes "box" the subject of
discussion. "The Gazebo is west of the Lawn" also falls into this case,
since "west of the Lawn" parses to a <span class="extract"><span class="extract-syntax">RELATIONSHIP_NT</span></span> subtree.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 36 - PROPER NOUN vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.36</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-rpt.html#SP4" class="function-link"><span class="function-syntax">Refiner::turn_player_to_yourself</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Diagrams::is_possessive_RELATIONSHIP</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;k-kind&gt;(Node::get_text(py-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">ALLOWED_NT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">UNPARSED_NOUN_NT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><a href="4-ass.html#SP9" class="function-link"><span class="function-syntax">Assertions::instantiate_related_common_nouns</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><a href="4-rk.html#SP1" class="function-link"><span class="function-syntax">Assertions::Relational::assert_subtree_in_relationship</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_37" class="paragraph-anchor"></a><b>&#167;6.3.37. Case 37. "On the table is a box." A mirror image, handling the inversion.</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 37 - RELATIONSHIP vs PROPER NOUN</span><span class="named-paragraph-number">6.3.37</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-rpt.html#SP4" class="function-link"><span class="function-syntax">Refiner::turn_player_to_yourself</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) { </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">    </span><a href="4-ass.html#SP9" class="function-link"><span class="function-syntax">Assertions::instantiate_related_common_nouns</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><a href="4-rk.html#SP1" class="function-link"><span class="function-syntax">Assertions::Relational::assert_subtree_in_relationship</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_38" class="paragraph-anchor"></a><b>&#167;6.3.38. Case 38.</b>"A door is a vehicle." This one's never legal; you can't equate
two whole domains. (We have the "kind of..." syntax instead.)
</p>

<pre class="definitions code-font"><span class="definition-keyword">define</span> <span class="constant-syntax">NAME_DESCRIPTION_CLASH_NOTE</span>
<span class="plain-syntax">    </span><span class="string-syntax">"Sometimes this happens because I've read too much into a name - for instance, "</span>
<span class="plain-syntax">    </span><span class="string-syntax">"'A dark room is a room' makes me read 'dark room' as 'dark' (an adjective I know) "</span>
<span class="plain-syntax">    </span><span class="string-syntax">"plus 'room', but maybe the writer actually meant a photographer's workshop. "</span>
<span class="plain-syntax">    </span><span class="string-syntax">"If you need to call something by a name which confuses me, one way is to use "</span>
<span class="plain-syntax">    </span><span class="string-syntax">"'called': for instance, 'West is a room called the dark room.' Another way is "</span>
<span class="plain-syntax">    </span><span class="string-syntax">"to call it something else here, and set the 'printed name' property to what you "</span>
<span class="plain-syntax">    </span><span class="string-syntax">"want the player to see - for instance, 'The photo lab is a room. The printed name "</span>
<span class="plain-syntax">    </span><span class="string-syntax">"of the photo lab is \"dark room\".'"</span>
</pre>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 38 - COMMON NOUN on both sides</span><span class="named-paragraph-number">6.3.38</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_38_1" class="named-paragraph-link"><span class="named-paragraph">Produce a problem if two values that vary are equated</span><span class="named-paragraph-number">6.3.38.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_38_2" class="named-paragraph-link"><span class="named-paragraph">Issue a problem for a namespace clash between a variable name and a kind</span><span class="named-paragraph-number">6.3.38.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">left_object</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">right_kind</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_subject</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">left_object</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_subject</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">right_kind</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">left_object</span><span class="plain-syntax"> == </span><span class="identifier-syntax">right_kind</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_SameKindEquated</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"The sentence %1 seems to be telling me that two descriptions, "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"both forms of %2, are the same. That's a little puzzling - "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"like saying that 'An open container is a container.' %P"</span>
<span class="plain-syntax">            </span><span class="constant-syntax">NAME_DESCRIPTION_CLASH_NOTE</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_DescriptionsEquated</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"The sentence %1 seems to be telling me that two descriptions, "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"one a form of %2 and the other of %3, are the same. That's a "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"little puzzling - like saying that 'An open door is a container.' %P"</span>
<span class="plain-syntax">            </span><span class="constant-syntax">NAME_DESCRIPTION_CLASH_NOTE</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_38_1" class="paragraph-anchor"></a><b>&#167;6.3.38.1. </b>For example,
</p>

<blockquote>
    <p>A number that varies is a text that varies.</p>
</blockquote>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Produce a problem if two values that vary are equated</span><span class="named-paragraph-number">6.3.38.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Specifications::is_new_variable_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">))) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Specifications::is_new_variable_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_VariablesEquated</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"The sentence %1 seems to tell me that '%2', which describes "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"a kind of variable, is the same as '%3', another description "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"of a kind of variable - but that doesn't make sense to me. "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"(Perhaps you intended one of these to be a specific variable, "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"but chose a wording which looked accidentally like a "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"general description?)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_38">&#167;6.3.38</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_38_2" class="paragraph-anchor"></a><b>&#167;6.3.38.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue a problem for a namespace clash between a variable name and a kind</span><span class="named-paragraph-number">6.3.38.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Specifications::is_new_variable_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_VarKOVClash</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"the name supplied for this new variable is a piece of text "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"which is not available because it has a rival meaning already"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"as a result of definitions made elsewhere. (Sometimes these "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"are indirect: for instance, defining a column in a table "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"called 'question' can make a name like 'container in question' "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"suddenly ambiguous and thus unsuitable to be a variable "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"name.) If you're getting this Problem message in the Standard "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"Rules or some other extension you need to use, then your "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"only option is to hunt through your own source text to see "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"what you have defined which might cause this clash."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_38">&#167;6.3.38</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_39" class="paragraph-anchor"></a><b>&#167;6.3.39. Case 39.</b>Sentences falling into this case have the form "X is a Y."; for
instance,
</p>

<blockquote>
    <p>The lacquered box is a container.</p>
</blockquote>

<p class="commentary">It might look as if
</p>

<blockquote>
    <p>A dead end is a kind of room. The Pitch is a room. East is a dead end.</p>
</blockquote>

<p class="commentary">would throw the last sentence into this case, which would be wrong, but we
avoid this by having the IF model code intervene. (Clearly this is a quirk
only occurring when we have named directions, an IF-like thing.)
</p>

<p class="commentary">It's usually plain wrong to say that a value has a given kind, because the value
has already been defined and its kind is long since established. (But we do
allow one case, where the declaration is redundant and harmless.)
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 39 - PROPER NOUN vs COMMON NOUN</span><span class="named-paragraph-number">6.3.39</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">InferenceSubjects::is_an_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">))) ||</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">InferenceSubjects::is_a_kind_of_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)))) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">) != </span><span class="identifier-syntax">KindSubjects::from_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">K_object</span><span class="plain-syntax">)) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">InferenceSubjects::is_a_kind_of_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">))</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP8" class="function-link"><span class="function-syntax">Assertions::issue_value_equation_problem</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_39_5" class="named-paragraph-link"><span class="named-paragraph">Assert that X is an instance of Y</span><span class="named-paragraph-number">6.3.39.5</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">g_spec</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">a_spec</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">g_kind</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">g_spec</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Specifications::is_new_variable_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">g_spec</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">g_kind</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::kind_of_new_variable_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">g_spec</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">a_kind</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_spec</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">var_set</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Rvalues::to_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_spec</span><span class="plain-syntax">)) ||</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Lvalues::get_storage_form</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_spec</span><span class="plain-syntax">) == </span><span class="identifier-syntax">NONLOCAL_VARIABLE_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">var_set</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Specifications::is_new_variable_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">g_spec</span><span class="plain-syntax">))</span>
<span class="plain-syntax">            </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_39_1" class="named-paragraph-link"><span class="named-paragraph">We're declaring the kind of the variable, not setting its value</span><span class="named-paragraph-number">6.3.39.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (((</span><span class="identifier-syntax">Specifications::is_kind_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">g_spec</span><span class="plain-syntax">)) ||</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">Specifications::is_new_variable_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">g_spec</span><span class="plain-syntax">)) ||</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">Specifications::is_description</span><span class="plain-syntax">(</span><span class="identifier-syntax">g_spec</span><span class="plain-syntax">)))</span>
<span class="plain-syntax">        &amp;&amp; (</span><span class="identifier-syntax">a_kind</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_kind</span><span class="plain-syntax">, </span><span class="identifier-syntax">g_kind</span><span class="plain-syntax">))</span>
<span class="plain-syntax">            </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_39_2" class="named-paragraph-link"><span class="named-paragraph">This sentence redundantly specifies the kind of value for a value</span><span class="named-paragraph-number">6.3.39.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::get_construct</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_kind</span><span class="plain-syntax">) == </span><span class="identifier-syntax">CON_description</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_39_4" class="named-paragraph-link"><span class="named-paragraph">Issue problem for trying to use a description as a literal</span><span class="named-paragraph-number">6.3.39.4</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">var_set</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_39_3" class="named-paragraph-link"><span class="named-paragraph">Dabble further in ruthless sarcasm</span><span class="named-paragraph-number">6.3.39.3</span></a></span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_kind_of</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">a_spec</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ChangedKind</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">        </span><span class="string-syntax">"Before reading %1, I already knew that '%2' is %3, "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"and it is too late to change now."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_39_1" class="paragraph-anchor"></a><b>&#167;6.3.39.1. </b>For example,
</p>

<blockquote>
    <p>The current prize value is a number that varies.</p>
</blockquote>

<p class="commentary">We silently allow the kind of a variable to be restated or narrowed, but not
contradicted.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">We're declaring the kind of the variable, not setting its value</span><span class="named-paragraph-number">6.3.39.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">nonlocal_variable</span><span class="plain-syntax"> *</span><span class="identifier-syntax">nlv</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Node::get_constant_nonlocal_variable</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">kind_as_declared</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NonlocalVariables::kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">nlv</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">constant_kind</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Specifications::is_new_variable_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">constant_kind</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::kind_of_new_variable_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::conforms_to</span><span class="plain-syntax">(</span><span class="identifier-syntax">constant_kind</span><span class="plain-syntax">, </span><span class="identifier-syntax">kind_as_declared</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"%u, %u\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">kind_as_declared</span><span class="plain-syntax">, </span><span class="identifier-syntax">constant_kind</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">nlv</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">nlv</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">name</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_kind</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">constant_kind</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">nlv</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_kind</span><span class="plain-syntax">(4, </span><span class="identifier-syntax">kind_as_declared</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Problems::quote_kind</span><span class="plain-syntax">(4, </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_GlobalRedeclared</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"The sentence %1 seems to tell me that '%2', which has already been "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"declared as %4, is instead %3 - but that would be a contradiction."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">kind_as_declared</span><span class="plain-syntax">, </span><span class="identifier-syntax">constant_kind</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">NonlocalVariables::set_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">nlv</span><span class="plain-syntax">, </span><span class="identifier-syntax">constant_kind</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_39">&#167;6.3.39</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_39_2" class="paragraph-anchor"></a><b>&#167;6.3.39.2. </b>We allow redundant declarations, except for numbers, where we are
sarcastic because the information is so obvious that it must be a mistake.
In the case of texts, we cause the text to be compiled into the I6 story
file: this may possibly be useful to I6 hackers.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This sentence redundantly specifies the kind of value for a value</span><span class="named-paragraph-number">6.3.39.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">var_set</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_kind</span><span class="plain-syntax">, </span><span class="identifier-syntax">K_number</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_Sarcasm1</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"%1: Grateful as I generally am for your guidance, "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"I think perhaps I could manage without this sentence."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_39">&#167;6.3.39</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_39_3" class="paragraph-anchor"></a><b>&#167;6.3.39.3. </b>My, aren't we charming?
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Dabble further in ruthless sarcasm</span><span class="named-paragraph-number">6.3.39.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_kind</span><span class="plain-syntax">, </span><span class="identifier-syntax">K_number</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_Sarcasm2</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span><span class="string-syntax">"%1: That, sir, is a damnable lie. '%2' is a number."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_kind</span><span class="plain-syntax">, </span><span class="identifier-syntax">K_text</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_Sarcasm3</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span><span class="string-syntax">"%1: And I am the King of Siam. '%2' is some text."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_39">&#167;6.3.39</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_39_4" class="paragraph-anchor"></a><b>&#167;6.3.39.4. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue problem for trying to use a description as a literal</span><span class="named-paragraph-number">6.3.39.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_DescAsLiteral</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span><span class="string-syntax">"%1: this seems to be using a description "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"as if it were a constant value, which isn't allowed. (Descriptions "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"can only be used as values to a limited extent.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_39">&#167;6.3.39</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_39_5" class="paragraph-anchor"></a><b>&#167;6.3.39.5. </b>Creation has already taken place, in that X does now exist, but any
stipulations on X &mdash; that it should have certain properties, or be in a
certain place, for instance &mdash; will not yet be enforced. These will be in
the "creation proposition" of Y, and we now assert this to be true about X.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Assert that X is an instance of Y</span><span class="named-paragraph-number">6.3.39.5</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">left_object</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_creation_proposition</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Binding::number_free</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">left_object</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Proposition is: $D\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">StandardProblems::subject_problem_at_sentence</span><span class="plain-syntax">(</span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_SubjectNotFree</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">left_object</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"seems to be set equal to something in a complicated relationship "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"with something else again"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"which is too much for me. Perhaps you're trying to do two things "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"at once, and it would be clearer to write it as two sentences?"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">left_object</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">K</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">KindPredicates::new_atom</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">, </span><span class="identifier-syntax">Terms::new_variable</span><span class="plain-syntax">(0));</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">left_object</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_39">&#167;6.3.39</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_40" class="paragraph-anchor"></a><b>&#167;6.3.40. Case 40. And so on, with one exemption.</b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 40 - COMMON NOUN vs PROPER NOUN</span><span class="named-paragraph-number">6.3.40</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">spec</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_40_1" class="named-paragraph-link"><span class="named-paragraph">Silently pass sentences like "The colours are red and blue."</span><span class="named-paragraph-number">6.3.40.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::Behaviour::is_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))))</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP8" class="function-link"><span class="function-syntax">Assertions::issue_value_equation_problem</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_CommonIsProper</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"this seems to say that a general description is something else"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"like saying that 'a door is 20'."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_40_1" class="paragraph-anchor"></a><b>&#167;6.3.40.1. </b>Suppose on the left we have a kind ("a colour", say) and on the right
a specific value ("blue", say). We silently allow this if the kinds agree, as
that's the case we fall into if we created "blue" in the Creator earlier;
no further work need be done, and we return to avoid a spurious problem
message.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Silently pass sentences like "The colours are red and blue."</span><span class="named-paragraph-number">6.3.40.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Rvalues::to_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">c_kind</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Instances::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Rvalues::to_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">v_kind</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">v_kind</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">c_kind</span><span class="plain-syntax">, </span><span class="identifier-syntax">v_kind</span><span class="plain-syntax">))) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_40">&#167;6.3.40</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41" class="paragraph-anchor"></a><b>&#167;6.3.41. Case 41.</b>In general, an object simply can't be set equal to a value, but
there's one exception: when the value is really an adjectival use implying
a property, rather than a noun. This takes some setting up: only the last of
these sentences falls into case 41.
</p>

<blockquote>
    <p>Colour is a kind of value. Green and blue are colours. A thing has a colour. The barn door is green.</p>
</blockquote>

<p class="commentary">There is also one case in which an object can be set equal to another object:
</p>

<blockquote>
    <p>East is the Pavilion.</p>
</blockquote>

<p class="commentary">(Of course this will only be true if the map feature is active.)
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 41 - PROPER NOUN on both sides</span><span class="named-paragraph-number">6.3.41</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_4" class="named-paragraph-link"><span class="named-paragraph">Allow the case of a property name, implicitly a property, being assigned to</span><span class="named-paragraph-number">6.3.41.4</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_5" class="named-paragraph-link"><span class="named-paragraph">Allow the case where a constant value is being assigned a property value</span><span class="named-paragraph-number">6.3.41.5</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_6" class="named-paragraph-link"><span class="named-paragraph">Allow the case where a constant response is being assigned a text value</span><span class="named-paragraph-number">6.3.41.6</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_3" class="named-paragraph-link"><span class="named-paragraph">Allow the case of a variable being assigned to</span><span class="named-paragraph-number">6.3.41.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_7" class="named-paragraph-link"><span class="named-paragraph">Allow the case of a new value for a kind which coincides with a property name</span><span class="named-paragraph-number">6.3.41.7</span></a></span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pname</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Properties::property_with_same_name_as</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pname</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><a href="4-pk.html#SP2" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::assert_property_value_from_property_subtree_infs</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pname</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">), </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">IF_MODULE</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Map::subject_is_a_direction</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">))) ||</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Map::subject_is_a_direction</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))))</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_1" class="named-paragraph-link"><span class="named-paragraph">This is a map connection referred to metonymically</span><span class="named-paragraph-number">6.3.41.1</span></a></span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">    #</span><span class="identifier-syntax">endif</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Rvalues::is_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)))</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_2" class="named-paragraph-link"><span class="named-paragraph">Otherwise it's just wrong to equate objects</span><span class="named-paragraph-number">6.3.41.2</span></a></span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Rvalues::is_CONSTANT_construction</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">), </span><span class="identifier-syntax">CON_property</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ObjectIsProperty</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"that seems to say that some object is a property"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"like saying 'The brick building is the description': if you want to specify "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"the description of the current object, try putting the sentence the other way "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"around ('The description is...')."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ObjectIsValue</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"I am reading the sentence %1 as saying that a thing called "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"'%2' is a value, but this makes no sense to me - it would be "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"like saying 'the chair is 10'."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_8" class="named-paragraph-link"><span class="named-paragraph">Produce a problem to the effect that two values can't be asserted equal</span><span class="named-paragraph-number">6.3.41.8</span></a></span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_1" class="paragraph-anchor"></a><b>&#167;6.3.41.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is a map connection referred to metonymically</span><span class="named-paragraph-number">6.3.41.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-ar.html#SP1" class="function-link"><span class="function-syntax">Anaphora::get_current_subject</span></a><span class="plain-syntax">() == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_NoMapOrigin</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"no location is under discussion to be the origin of this map connection"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"so this is like starting with 'North is the Aviary': I can't tell where from."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">target</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">), *</span><span class="identifier-syntax">way</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Map::subject_is_a_direction</span><span class="plain-syntax">(</span><span class="identifier-syntax">target</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">target</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">); </span><span class="identifier-syntax">way</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">target</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_MapNonObject</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="string-syntax">"this seems to make a map connection to something which is "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"not an object"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"like saying '20 is north'. This is an odd thing "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"to say, and makes me think that I've misunderstood you."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Map::connect</span><span class="plain-syntax">(</span><a href="2-ar.html#SP1" class="function-link"><span class="function-syntax">Anaphora::get_current_subject</span></a><span class="plain-syntax">(), </span><span class="identifier-syntax">target</span><span class="plain-syntax">, </span><span class="identifier-syntax">way</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41">&#167;6.3.41</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_2" class="paragraph-anchor"></a><b>&#167;6.3.41.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Otherwise it's just wrong to equate objects</span><span class="named-paragraph-number">6.3.41.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ProperIsItself</span><span class="plain-syntax">),</span>
<span class="plain-syntax">            </span><span class="string-syntax">"this seems to say that something is itself"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="string-syntax">"like saying 'the coin is the coin'. This is an odd thing "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"to say, and makes me think that I've misunderstood you."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;control-structure-phrase&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_IfInAssertion</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"I am reading the sentence %1 as a declaration of the initial "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"state of the world, so I'm expecting that it will be definite. "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"The only way I can construe it that way is by thinking that "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"'%2' and '%3' are two different things, but that doesn't make "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"sense, and the 'if' makes me think that perhaps you did not "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"mean this as a definite statement after all. Although 'if...' "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"is often used in rules and definitions of what to do in given "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"circumstances, it shouldn't be used in a direct assertion."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Rvalues::is_object</span><span class="plain-syntax">(</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)))</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_2_2" class="named-paragraph-link"><span class="named-paragraph">Issue the generic problem message for equating objects</span><span class="named-paragraph-number">6.3.41.2.2</span></a></span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_2_1" class="named-paragraph-link"><span class="named-paragraph">Issue a problem for equating an object to a value</span><span class="named-paragraph-number">6.3.41.2.1</span></a></span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41">&#167;6.3.41</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_2_1" class="paragraph-anchor"></a><b>&#167;6.3.41.2.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue a problem for equating an object to a value</span><span class="named-paragraph-number">6.3.41.2.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_kind_of</span><span class="plain-syntax">(4, </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_kind_of</span><span class="plain-syntax">(5, </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ObjectAndValueEquated</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">        </span><span class="string-syntax">"The sentence %1 seems to say that '%2', which I think is %4, and "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"'%3', which I think is %5, are the same. %P"</span>
<span class="plain-syntax">        </span><span class="string-syntax">"That can't be right, so I must have misunderstood. Perhaps you "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"intended to make something new, but it accidentally had the same "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"name as something already existing?"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41_2">&#167;6.3.41.2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_2_2" class="paragraph-anchor"></a><b>&#167;6.3.41.2.2. </b>This message is seen so often...
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue the generic problem message for equating objects</span><span class="named-paragraph-number">6.3.41.2.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="4-ass.html#SP6_3_41_2_2_1" class="named-paragraph-link"><span class="named-paragraph">Choose random antagonists for variety</span><span class="named-paragraph-number">6.3.41.2.2.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ChalkCheese</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">        </span><span class="string-syntax">"The sentence %1 appears to say two things are the same - I am reading '%2' "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"and '%3' as two different things, and therefore it makes no sense to say "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"that one is the other: it would be like saying that '%4 is %5'. It would "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"be all right if the second thing were the name of a kind, perhaps with "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"properties: for instance '%6 is a lighted room' says that something "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"called %6 exists and that it is a 'room', which is a kind I know about, "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"combined with a property called 'lighted' which I also know about."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">UsingProblems::diagnose_further</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41_2">&#167;6.3.41.2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_2_2_1" class="paragraph-anchor"></a><b>&#167;6.3.41.2.2.1. </b>...that we vary it randomly for fun. The low bits of the current time are not
exactly a crypto-quality source of entropy, but they'll do for us. (We have
to turn the variability off in fixed-RNG mode for the sake of the test
suite: it would be annoying to verify this problem message otherwise.)
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Choose random antagonists for variety</span><span class="named-paragraph-number">6.3.41.2.2.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">char</span><span class="plain-syntax"> *</span><span class="identifier-syntax">P</span><span class="plain-syntax">, *</span><span class="identifier-syntax">Q</span><span class="plain-syntax">, *</span><span class="identifier-syntax">In</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">variant</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Task::rng_seed</span><span class="plain-syntax">() == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">variant</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">time</span><span class="plain-syntax">(0))&amp;15;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">switch</span><span class="plain-syntax">(</span><span class="identifier-syntax">variant</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">1</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"the chalk"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"the cheese"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Dairy Products School"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">2</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"St Peter"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"St Paul"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Pearly Gates"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">3</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Tom"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Jerry"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Mouse-Hole"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">4</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Clark Kent"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Lex Luthor"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Metropolis"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">5</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Ron"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Hermione"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Hogsmeade"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">6</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Tarzan"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Jane"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Treehouse"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">7</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Adam"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Eve"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Land of Nod"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">8</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Laurel"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Hardy"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Blue-Ridge Mountains"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">9</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Aeschylus"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Euripides"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Underworld"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">10</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Choucas"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Hibou"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"The Hall"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">11</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"John"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Paul"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Abbey Road"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">12</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Poirot"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Hastings"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"St Mary Mead"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">13</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"House"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Wilson"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Princeton Plainsboro"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">14</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Adams"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Jefferson"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Virginia"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">15</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Antony"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Cleopatra"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Alexandria"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">16</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Emmet"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Wildstyle"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Bricksburg"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">17</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Stanley"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Livingstone"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Africa"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">18</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"Jeeves"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Wooster"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Totleigh Towers"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">19</span><span class="plain-syntax">: </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"John"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"Timus"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"The Lab"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">default:</span><span class="plain-syntax"> </span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="string-syntax">"the hawk"</span><span class="plain-syntax">; </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><span class="string-syntax">"the handsaw"</span><span class="plain-syntax">; </span><span class="identifier-syntax">In</span><span class="plain-syntax"> = </span><span class="string-syntax">"Elsinore"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_text</span><span class="plain-syntax">(4, </span><span class="identifier-syntax">P</span><span class="plain-syntax">); </span><span class="identifier-syntax">Problems::quote_text</span><span class="plain-syntax">(5, </span><span class="identifier-syntax">Q</span><span class="plain-syntax">); </span><span class="identifier-syntax">Problems::quote_text</span><span class="plain-syntax">(6, </span><span class="identifier-syntax">In</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41_2_2">&#167;6.3.41.2.2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_3" class="paragraph-anchor"></a><b>&#167;6.3.41.3. </b>Usually it makes no sense to equate two values: "5 is 10",
for instance, and we produce a variety of more or less scornful errors.
</p>

<blockquote>
    <p>10 is 15. 14 is a number. "Fish" is text. The turn count is a text. 19 is a rulebook. "Frog" is a number. Before rules is a rule.</p>
</blockquote>

<p class="commentary">But we do take polite notice when X is a variable name and Y is an
initial value with a compatible type, as in the second sentence here:
</p>

<blockquote>
    <p>The innings total is a number that varies. The innings total is 101.</p>
</blockquote>

<p class="commentary">We set such variables on traverse 2 because not all of the object values exist
yet during traverse 1.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Allow the case of a variable being assigned to</span><span class="named-paragraph-number">6.3.41.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Lvalues::get_storage_form</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) == </span><span class="identifier-syntax">NONLOCAL_VARIABLE_NT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">nonlocal_variable</span><span class="plain-syntax"> *</span><span class="identifier-syntax">nlv</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_constant_nonlocal_variable</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">nlv</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">val</span><span class="plain-syntax">) </span><span class="identifier-syntax">Node::set_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NonlocalVariables::substitute_constants</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><a href="4-pk.html#SP1" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::initialise_global_variable</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">nlv</span><span class="plain-syntax">, </span><span class="identifier-syntax">val</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::is</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</span><span class="plain-syntax">, </span><span class="identifier-syntax">CONSTANT_NT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">PluginCalls::variable_set_warning</span><span class="plain-syntax">(</span><span class="identifier-syntax">nlv</span><span class="plain-syntax">, </span><span class="identifier-syntax">val</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                        </span><a href="4-pk.html#SP1" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::initialise_global_variable</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">nlv</span><span class="plain-syntax">, </span><span class="identifier-syntax">val</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41">&#167;6.3.41</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_4" class="paragraph-anchor"></a><b>&#167;6.3.41.4. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Allow the case of a property name, implicitly a property, being assigned to</span><span class="named-paragraph-number">6.3.41.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Rvalues::is_CONSTANT_construction</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">), </span><span class="identifier-syntax">CON_property</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">talking_about</span><span class="plain-syntax"> = </span><a href="2-ar.html#SP1" class="function-link"><span class="function-syntax">Anaphora::get_current_subject</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">talking_about</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">UsingProblems::assertion_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_NothingDiscussed</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="string-syntax">"nothing is under discussion which might have this property"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><span class="string-syntax">"so this is like starting with 'The description is \"Orange.\"': "</span>
<span class="plain-syntax">                </span><span class="string-syntax">"I can't tell what of."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;negated-clause&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)))</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">StandardProblems::negative_sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_NonValue2</span><span class="plain-syntax">));</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><a href="4-pk.html#SP2" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::assert_property_value_from_property_subtree_infs</span></a><span class="plain-syntax">(</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">Rvalues::to_property</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)), </span><span class="identifier-syntax">talking_about</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41">&#167;6.3.41</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_5" class="paragraph-anchor"></a><b>&#167;6.3.41.5. </b>Here we're watching out for assertions like:
</p>

<blockquote>
    <p>The Abruzzi Spur route is grade 5.</p>
</blockquote>

<p class="commentary">where "Abruzzi Spur route" is a value of kind "K2 ascent route", and values
of this kind have been given a property "difficulty rating" which is also
the name of a kind in turn, one value of which is "grade 5". To the A-parser
both sides are <span class="extract"><span class="extract-syntax">VALUE</span></span> nodes; "grade 5" is being used adjectivally here,
but that's not evident without a lot of contextual checking.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Allow the case where a constant value is being assigned a property value</span><span class="named-paragraph-number">6.3.41.5</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">constant</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Rvalues::to_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">constant</span><span class="plain-syntax">)) ||</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Specifications::is_kind_like</span><span class="plain-syntax">(</span><span class="identifier-syntax">constant</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">instance</span><span class="plain-syntax"> *</span><span class="identifier-syntax">q</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Rvalues::to_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pname</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Properties::property_with_same_name_as</span><span class="plain-syntax">(</span><span class="identifier-syntax">Instances::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">q</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pname</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">)</span>
<span class="plain-syntax">                </span><a href="4-pk.html#SP2" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::assert_property_value_from_property_subtree_infs</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pname</span><span class="plain-syntax">, </span><span class="identifier-syntax">Instances::as_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">q</span><span class="plain-syntax">), </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41">&#167;6.3.41</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_6" class="paragraph-anchor"></a><b>&#167;6.3.41.6. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Allow the case where a constant response is being assigned a text value</span><span class="named-paragraph-number">6.3.41.6</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">constant</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Rvalues::is_CONSTANT_of_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">constant</span><span class="plain-syntax">, </span><span class="identifier-syntax">K_response</span><span class="plain-syntax">)) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">Rvalues::is_CONSTANT_of_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</span><span class="plain-syntax">, </span><span class="identifier-syntax">K_text</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">rule</span><span class="plain-syntax"> *</span><span class="identifier-syntax">R</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Rvalues::to_rule</span><span class="plain-syntax">(</span><span class="identifier-syntax">constant</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">constant</span><span class="plain-syntax">, </span><span class="identifier-syntax">response_code_ANNOT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><a href="6-rls.html#SP22" class="function-link"><span class="function-syntax">Rules::now_rule_needs_response</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">R</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41">&#167;6.3.41</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_7" class="paragraph-anchor"></a><b>&#167;6.3.41.7. </b>This is to cope with text such as
</p>

<blockquote>
    <p>Plastic is a material.</p>
</blockquote>

<p class="commentary">where "material" is the name of both a kind of value, and also a property.
We find ourselves here because we've been considering "material" as the
property name (a proper noun), not the kind name (a common noun), and we
need to switch interpretations to avoid the problem message.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Allow the case of a new value for a kind which coincides with a property name</span><span class="named-paragraph-number">6.3.41.7</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Rvalues::is_CONSTANT_construction</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">), </span><span class="identifier-syntax">CON_property</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Rvalues::to_property</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Properties::is_either_or</span><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">ValueProperties::coincides_with_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K</span><span class="plain-syntax"> = </span><span class="identifier-syntax">ValueProperties::kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_type_and_clear_annotations</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::set_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">, </span><span class="identifier-syntax">Specifications::from_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">));</span>
<span class="plain-syntax">            </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41">&#167;6.3.41</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_41_8" class="paragraph-anchor"></a><b>&#167;6.3.41.8. </b>All other attempts are doomed.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Produce a problem to the effect that two values can't be asserted equal</span><span class="named-paragraph-number">6.3.41.8</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_kind_of</span><span class="plain-syntax">(4, </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">Problems::quote_kind_of</span><span class="plain-syntax">(5, </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)),</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_SimilarValuesEquated</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"Before reading %1, I already knew that '%2' is %4 and "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"'%3' likewise: so they are specific values, and saying "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"that they are equal will not make it so."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_DissimilarValuesEquated</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"Before reading %1, I already knew that '%2' is %4 and "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"'%3' is %5: so they are specific values, and saying "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"that they are equal will not make it so."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3_41">&#167;6.3.41</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. </b>Equating values in an assertion is never allowed, but there are a variety of
possible problem messages, because it usually occurs as a symptom of a failed
attempt to create something. The following is used to pick up sentences like
</p>

<blockquote>
    <p>Something called mauve is a colour.</p>
</blockquote>

<p class="commentary">which fail because Inform reads "something" as "some thing", i.e., as
referring to a thing which then can't be equated with a colour.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="function-syntax">&lt;something-loose-diagnosis&gt;</span>
<span class="plain-syntax">    *** </span><span class="identifier-syntax">something</span><span class="plain-syntax"> ***</span>
</pre>
<p class="commentary firstcommentary"><a id="SP7_1" class="paragraph-anchor"></a><b>&#167;7.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue PM_EquatesSomethingToValue problem</span><span class="named-paragraph-number">7.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_EquatesSomethingToValue</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"that seems to say that an object is the same as a value"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"which must be wrong. This can happen if the word 'something' is "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"used loosely - I read it as 'some thing', so I think it has to "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"refer to a thing, which is a kind of object. A sentence like "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"'Something called mauve is a colour' trips me up because mauve "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"is a value, so it isn't an object, and doesn't match 'something'."</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP7">&#167;7</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP6_3_42" class="paragraph-anchor"></a><b>&#167;6.3.42. Case 42.</b>This is possibly a variation on 41 where an adjective is also
in some contexts a noun. For example:
</p>

<blockquote>
    <p>Hostile hates friendly.</p>
</blockquote>

<p class="commentary">where "hostile" and "friendly" are values of an enumerated kind but which
can also be used adjectivally.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Case 42 - ADJECTIVE vs RELATIONSHIP</span><span class="named-paragraph-number">6.3.42</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><a href="4-rpt.html#SP6" class="function-link"><span class="function-syntax">Refiner::nominalise_adjective</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) ||</span>
<span class="plain-syntax">        (</span><a href="4-rpt.html#SP6" class="function-link"><span class="function-syntax">Refiner::nominalise_adjective</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP6" class="function-link"><span class="function-syntax">Assertions::make_coupling</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">BelievedImpossible</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"that seems to relate an adjective to something"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"which must be wrong. (This can sometimes happen if the same word can "</span>
<span class="plain-syntax">        </span><span class="string-syntax">"be used both as an adjective and a noun, and I misunderstand.)"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-ass.html#SP6_3">&#167;6.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. </b></p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::issue_value_equation_problem</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">Assertions::issue_value_equation_problem</span></span>:<br/><a href="4-ass.html#SP6_3_39">&#167;6.3.39</a>, <a href="4-ass.html#SP6_3_40">&#167;6.3.40</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">px</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">py</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="function-syntax">&lt;something-loose-diagnosis&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">))))</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) != </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">        ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">) != </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">) != </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$T"</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">); </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$T"</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"Assert PX of type PY on bad node types"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$T"</span><span class="plain-syntax">, </span><span class="identifier-syntax">px</span><span class="plain-syntax">); </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$T"</span><span class="plain-syntax">, </span><span class="identifier-syntax">py</span><span class="plain-syntax">);</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">InferenceSubjects::where_created</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)) != </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">InferenceSubjects::where_created</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">)));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_CantUncreate</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"In order to act on %2, I seem to need to give "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"a new meaning to '%1', which currently means something created by the "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"earlier sentence %3. That must be wrong, so I'm guessing that there "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"is an accidental clash of names. This sometimes happens when "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"adjectives are being made after objects whose names include them: "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"for instance, defining 'big' as an adjective after having already "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"made a 'big top'. The simplest way to avoid this is to define "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"the adjectives in question first."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">) == </span><span class="identifier-syntax">PROPER_NOUN_NT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">) == </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(2, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Wordings::nonempty</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">))) </span><span class="identifier-syntax">Problems::quote_wording</span><span class="plain-syntax">(3, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">Problems::quote_text</span><span class="plain-syntax">(3, </span><span class="string-syntax">"(something not given an explicit name)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::handmade_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_IdentityUnclear</span><span class="plain-syntax">));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_segment</span><span class="plain-syntax">(</span>
<span class="plain-syntax">            </span><span class="string-syntax">"The sentence %1 seems to tell me that '%2' and '%3' have to be "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"the same, but it looks odd to me. '%2' is something generic - "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"not something definite; but '%3' is (presumably) something "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"specific. So it's as if you'd written 'A room is the Sydney "</span>
<span class="plain-syntax">            </span><span class="string-syntax">"Opera House'. (Which room, exactly? You see the trouble.)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">Problems::issue_problem_end</span><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">BelievedImpossible</span><span class="plain-syntax">),</span>
<span class="plain-syntax">        </span><span class="string-syntax">"that seems to say that an object is the same as a value"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><span class="string-syntax">"which must be wrong."</span><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. Instantiation of related kinds.</b></p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::instantiate_related_common_nouns</span><button class="popup" onclick="togglePopup('usagePopup6')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup6">Usage of <span class="code-font"><span class="function-syntax">Assertions::instantiate_related_common_nouns</span></span>:<br/><a href="4-ass.html#SP6_3_36">&#167;6.3.36</a>, <a href="4-ass.html#SP6_3_37">&#167;6.3.37</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><a href="4-ass.html#SP9" class="function-link"><span class="function-syntax">Assertions::instantiate_related_common_nouns_r</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">p</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>

<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::instantiate_related_common_nouns_r</span><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">from</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">at</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">at</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">at</span><span class="plain-syntax">) == </span><span class="identifier-syntax">COMMON_NOUN_NT</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><a href="4-tc.html#SP8" class="function-link"><span class="function-syntax">Assertions::Creator::convert_instance_to_nounphrase</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">at</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Node::get_relationship</span><span class="plain-syntax">(</span><span class="identifier-syntax">from</span><span class="plain-syntax">));</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">at</span><span class="plain-syntax">) == </span><span class="identifier-syntax">AND_NT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP9" class="function-link"><span class="function-syntax">Assertions::instantiate_related_common_nouns_r</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">from</span><span class="plain-syntax">, </span><span class="identifier-syntax">at</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP9" class="function-link"><span class="function-syntax">Assertions::instantiate_related_common_nouns_r</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">from</span><span class="plain-syntax">, </span><span class="identifier-syntax">at</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">at</span><span class="plain-syntax">) == </span><span class="identifier-syntax">WITH_NT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><a href="4-ass.html#SP9" class="function-link"><span class="function-syntax">Assertions::instantiate_related_common_nouns_r</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">from</span><span class="plain-syntax">, </span><span class="identifier-syntax">at</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><a href="4-pk.html#SP2" class="function-link"><span class="function-syntax">Assertions::PropertyKnowledge::assert_property_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">at</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">, </span><span class="identifier-syntax">at</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. Adjective list trees.</b></p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Assertions::is_adjlist</span><button class="popup" onclick="togglePopup('usagePopup7')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup7">Usage of <span class="code-font"><span class="function-syntax">Assertions::is_adjlist</span></span>:<br/><a href="4-ass.html#SP6_3_2">&#167;6.3.2</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">p</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_type</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">ADJECTIVE_NT:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">AND_NT:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> ((</span><a href="4-ass.html#SP10" class="function-link"><span class="function-syntax">Assertions::is_adjlist</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">)) &amp;&amp; (</span><a href="4-ass.html#SP10" class="function-link"><span class="function-syntax">Assertions::is_adjlist</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)));</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">default:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">}</span>
</pre>
<nav role="progress"><div class="progresscontainer">
    <ul class="progressbar"><li class="progressprev"><a href="4-tc.html">&#10094;</a></li><li class="progresschapter"><a href="P-wtmd.html">P</a></li><li class="progresschapter"><a href="1-am.html">1</a></li><li class="progresschapter"><a href="2-bv.html">2</a></li><li class="progresschapter"><a href="3-dlr.html">3</a></li><li class="progresscurrentchapter">4</li><li class="progresssection"><a href="4-nr.html">nr</a></li><li class="progresssection"><a href="4-rpt.html">rpt</a></li><li class="progresssection"><a href="4-tc.html">tc</a></li><li class="progresscurrent">ass</li><li class="progresssection"><a href="4-npa.html">npa</a></li><li class="progresssection"><a href="4-pk.html">pk</a></li><li class="progresssection"><a href="4-rk.html">rk</a></li><li class="progresssection"><a href="4-ass2.html">ass2</a></li><li class="progresssection"><a href="4-imp.html">imp</a></li><li class="progresschapter"><a href="5-id.html">5</a></li><li class="progresschapter"><a href="6-rls.html">6</a></li><li class="progresschapter"><a href="7-tc.html">7</a></li><li class="progresschapter"><a href="8-kpr.html">8</a></li><li class="progressnext"><a href="4-npa.html">&#10095;</a></li></ul></div>
</nav><!-- End of weave -->

		</main>
	</body>
</html>

